zzz_generated/chip-tool-darwin/zap-generated/cluster/CHIPTestClustersObjc.mm

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

// THIS FILE IS GENERATED BY ZAP
#import <Foundation/Foundation.h>

#import "CHIP/CHIP.h"

#import "CHIPCallbackBridge_internal.h" // For CHIPDefaultSuccessCallbackBridge, etc
#import "CHIPCluster_internal.h" // For self.callbackQueue

#import "zap-generated/cluster/CHIPTestClustersObjc.h"

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

using chip::Callback::Callback;
using chip::Callback::Cancelable;
using namespace chip::app::Clusters;

@interface CHIPTestAccessControl ()
@property (readonly) chip::Controller::AccessControlCluster cppCluster;
@end

@implementation CHIPTestAccessControl

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeSubjectsPerAccessControlEntryWithValue:(NSNumber * _Nonnull)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::SubjectsPerAccessControlEntry::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTargetsPerAccessControlEntryWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::TargetsPerAccessControlEntry::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAccessControlEntriesPerFabricWithValue:(NSNumber * _Nonnull)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::AccessControlEntriesPerFabric::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccessControl::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestAccountLogin ()
@property (readonly) chip::Controller::AccountLoginCluster cppCluster;
@end

@implementation CHIPTestAccountLogin

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccountLogin::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccountLogin::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccountLogin::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccountLogin::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AccountLogin::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestAdministratorCommissioning ()
@property (readonly) chip::Controller::AdministratorCommissioningCluster cppCluster;
@end

@implementation CHIPTestAdministratorCommissioning

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeWindowStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::WindowStatus::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAdminFabricIndexWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::AdminFabricIndex::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAdminVendorIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::AdminVendorId::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AdministratorCommissioning::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestApplicationBasic ()
@property (readonly) chip::Controller::ApplicationBasicCluster cppCluster;
@end

@implementation CHIPTestApplicationBasic

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeVendorNameWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::VendorName::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeVendorIDWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::VendorID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApplicationNameWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::ApplicationName::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductIDWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::ProductID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApplicationWithValue:(CHIPApplicationBasicClusterApplicationBasicApplication * _Nonnull)value
                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::Application::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue.catalogVendorId = value.catalogVendorId.unsignedShortValue;
            cppValue.applicationId = [self asCharSpan:value.applicationId];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::Status::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApplicationVersionWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::ApplicationVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAllowedVendorListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::AllowedVendorList::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] = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(
                            element_0.unsignedShortValue);
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationBasic::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestApplicationLauncher ()
@property (readonly) chip::Controller::ApplicationLauncherCluster cppCluster;
@end

@implementation CHIPTestApplicationLauncher

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeCatalogListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::CatalogList::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.unsignedShortValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ApplicationLauncher::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestAudioOutput ()
@property (readonly) chip::Controller::AudioOutputCluster cppCluster;
@end

@implementation CHIPTestAudioOutput

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeOutputListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::OutputList::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:[CHIPAudioOutputClusterOutputInfo class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPAudioOutputClusterOutputInfo *) value[i_0];
                        listHolder_0->mList[i_0].index = element_0.index.unsignedCharValue;
                        listHolder_0->mList[i_0].outputType
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].outputType)>>(
                                element_0.outputType.unsignedCharValue);
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentOutputWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::CurrentOutput::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = AudioOutput::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBarrierControl ()
@property (readonly) chip::Controller::BarrierControlCluster cppCluster;
@end

@implementation CHIPTestBarrierControl

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeBarrierMovingStateWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierMovingState::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierSafetyStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierSafetyStatus::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierCapabilitiesWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierCapabilities::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBarrierPositionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::BarrierPosition::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BarrierControl::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBasic ()
@property (readonly) chip::Controller::BasicCluster cppCluster;
@end

@implementation CHIPTestBasic

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeDataModelRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::DataModelRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeVendorNameWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::VendorName::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeVendorIDWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::VendorID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductNameWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::ProductName::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductIDWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::ProductID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHardwareVersionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::HardwareVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHardwareVersionStringWithValue:(NSString * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::HardwareVersionString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSoftwareVersionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::SoftwareVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSoftwareVersionStringWithValue:(NSString * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::SoftwareVersionString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeManufacturingDateWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::ManufacturingDate::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePartNumberWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::PartNumber::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductURLWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::ProductURL::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductLabelWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::ProductLabel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSerialNumberWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::SerialNumber::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReachableWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::Reachable::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUniqueIDWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::UniqueID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCapabilityMinimaWithValue:(CHIPBasicClusterCapabilityMinimaStruct * _Nonnull)value
                              completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::CapabilityMinima::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue.caseSessionsPerFabric = value.caseSessionsPerFabric.unsignedShortValue;
            cppValue.subscriptionsPerFabric = value.subscriptionsPerFabric.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Basic::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBinaryInputBasic ()
@property (readonly) chip::Controller::BinaryInputBasicCluster cppCluster;
@end

@implementation CHIPTestBinaryInputBasic

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributePolarityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::Polarity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStatusFlagsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::StatusFlags::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApplicationTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::ApplicationType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BinaryInputBasic::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBinding ()
@property (readonly) chip::Controller::BindingCluster cppCluster;
@end

@implementation CHIPTestBinding

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Binding::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Binding::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Binding::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Binding::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Binding::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBooleanState ()
@property (readonly) chip::Controller::BooleanStateCluster cppCluster;
@end

@implementation CHIPTestBooleanState

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeStateValueWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BooleanState::Attributes::StateValue::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BooleanState::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BooleanState::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BooleanState::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BooleanState::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BooleanState::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBridgedActions ()
@property (readonly) chip::Controller::BridgedActionsCluster cppCluster;
@end

@implementation CHIPTestBridgedActions

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeActionListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::ActionList::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:[CHIPBridgedActionsClusterActionStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPBridgedActionsClusterActionStruct *) value[i_0];
                        listHolder_0->mList[i_0].actionID = element_0.actionID.unsignedShortValue;
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                        listHolder_0->mList[i_0].type
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].type)>>(
                                element_0.type.unsignedCharValue);
                        listHolder_0->mList[i_0].endpointListID = element_0.endpointListID.unsignedShortValue;
                        listHolder_0->mList[i_0].supportedCommands = element_0.supportedCommands.unsignedShortValue;
                        listHolder_0->mList[i_0].status
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].status)>>(
                                element_0.status.unsignedCharValue);
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEndpointListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::EndpointList::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:[CHIPBridgedActionsClusterEndpointListStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPBridgedActionsClusterEndpointListStruct *) value[i_0];
                        listHolder_0->mList[i_0].endpointListID = element_0.endpointListID.unsignedShortValue;
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                        listHolder_0->mList[i_0].type
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].type)>>(
                                element_0.type.unsignedCharValue);
                        {
                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].endpoints)>;
                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
                            if (element_0.endpoints.count != 0) {
                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.endpoints.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.endpoints.count; ++i_2) {
                                    if (![element_0.endpoints[i_2] isKindOfClass:[NSNumber class]]) {
                                        // Wrong kind of value.
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    auto element_2 = (NSNumber *) element_0.endpoints[i_2];
                                    listHolder_2->mList[i_2] = element_2.unsignedShortValue;
                                }
                                listHolder_0->mList[i_0].endpoints = ListType_2(listHolder_2->mList, element_0.endpoints.count);
                            } else {
                                listHolder_0->mList[i_0].endpoints = ListType_2();
                            }
                        }
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSetupUrlWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::SetupUrl::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedActions::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestBridgedDeviceBasic ()
@property (readonly) chip::Controller::BridgedDeviceBasicCluster cppCluster;
@end

@implementation CHIPTestBridgedDeviceBasic

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeVendorNameWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorName::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeVendorIDWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::VendorID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductNameWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductName::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHardwareVersionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHardwareVersionStringWithValue:(NSString * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::HardwareVersionString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSoftwareVersionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSoftwareVersionStringWithValue:(NSString * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::SoftwareVersionString::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeManufacturingDateWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::ManufacturingDate::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePartNumberWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::PartNumber::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductURLWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductURL::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeProductLabelWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::ProductLabel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSerialNumberWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::SerialNumber::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReachableWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::Reachable::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUniqueIDWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::UniqueID::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = BridgedDeviceBasic::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestChannel ()
@property (readonly) chip::Controller::ChannelCluster cppCluster;
@end

@implementation CHIPTestChannel

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeChannelListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::ChannelList::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:[CHIPChannelClusterChannelInfo class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPChannelClusterChannelInfo *) value[i_0];
                        listHolder_0->mList[i_0].majorNumber = element_0.majorNumber.unsignedShortValue;
                        listHolder_0->mList[i_0].minorNumber = element_0.minorNumber.unsignedShortValue;
                        if (element_0.name != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].name.Emplace();
                            definedValue_2 = [self asCharSpan:element_0.name];
                        }
                        if (element_0.callSign != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].callSign.Emplace();
                            definedValue_2 = [self asCharSpan:element_0.callSign];
                        }
                        if (element_0.affiliateCallSign != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].affiliateCallSign.Emplace();
                            definedValue_2 = [self asCharSpan:element_0.affiliateCallSign];
                        }
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLineupWithValue:(CHIPChannelClusterLineupInfo * _Nullable)value
                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::Lineup::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0.operatorName = [self asCharSpan:value.operatorName];
                if (value.lineupName != nil) {
                    auto & definedValue_2 = nonNullValue_0.lineupName.Emplace();
                    definedValue_2 = [self asCharSpan:value.lineupName];
                }
                if (value.postalCode != nil) {
                    auto & definedValue_2 = nonNullValue_0.postalCode.Emplace();
                    definedValue_2 = [self asCharSpan:value.postalCode];
                }
                nonNullValue_0.lineupInfoType = static_cast<std::remove_reference_t<decltype(nonNullValue_0.lineupInfoType)>>(
                    value.lineupInfoType.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentChannelWithValue:(CHIPChannelClusterChannelInfo * _Nullable)value
                            completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::CurrentChannel::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0.majorNumber = value.majorNumber.unsignedShortValue;
                nonNullValue_0.minorNumber = value.minorNumber.unsignedShortValue;
                if (value.name != nil) {
                    auto & definedValue_2 = nonNullValue_0.name.Emplace();
                    definedValue_2 = [self asCharSpan:value.name];
                }
                if (value.callSign != nil) {
                    auto & definedValue_2 = nonNullValue_0.callSign.Emplace();
                    definedValue_2 = [self asCharSpan:value.callSign];
                }
                if (value.affiliateCallSign != nil) {
                    auto & definedValue_2 = nonNullValue_0.affiliateCallSign.Emplace();
                    definedValue_2 = [self asCharSpan:value.affiliateCallSign];
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Channel::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestColorControl ()
@property (readonly) chip::Controller::ColorControlCluster cppCluster;
@end

@implementation CHIPTestColorControl

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeCurrentHueWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::CurrentHue::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentSaturationWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::CurrentSaturation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRemainingTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::RemainingTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentXWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::CurrentX::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentYWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::CurrentY::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDriftCompensationWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::DriftCompensation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCompensationTextWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::CompensationText::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorTemperatureWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorTemperature::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfPrimariesWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::NumberOfPrimaries::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary1XWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary1X::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary1YWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary1Y::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary1IntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary1Intensity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary2XWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary2X::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary2YWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary2Y::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary2IntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary2Intensity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary3XWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary3X::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary3YWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary3Y::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary3IntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary3Intensity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary4XWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary4X::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary4YWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary4Y::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary4IntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary4Intensity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary5XWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary5X::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary5YWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary5Y::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary5IntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary5Intensity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary6XWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary6X::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary6YWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary6Y::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePrimary6IntensityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::Primary6Intensity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnhancedCurrentHueWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::EnhancedCurrentHue::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEnhancedColorModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::EnhancedColorMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorLoopActiveWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorLoopActive::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorLoopDirectionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorLoopDirection::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorLoopTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorLoopTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorLoopStartEnhancedHueWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorLoopStartEnhancedHue::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorLoopStoredEnhancedHueWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorLoopStoredEnhancedHue::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorCapabilitiesWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorCapabilities::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorTempPhysicalMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeColorTempPhysicalMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ColorTempPhysicalMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCoupleColorTempToLevelMinMiredsWithValue:(NSNumber * _Nonnull)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::CoupleColorTempToLevelMinMireds::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ColorControl::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestContentLauncher ()
@property (readonly) chip::Controller::ContentLauncherCluster cppCluster;
@end

@implementation CHIPTestContentLauncher

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeAcceptHeaderWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::AcceptHeader::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:[NSString class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSString *) value[i_0];
                        listHolder_0->mList[i_0] = [self asCharSpan:element_0];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ContentLauncher::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestDescriptor ()
@property (readonly) chip::Controller::DescriptorCluster cppCluster;
@end

@implementation CHIPTestDescriptor

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeDeviceListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::DeviceList::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:[CHIPDescriptorClusterDeviceType class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPDescriptorClusterDeviceType *) value[i_0];
                        listHolder_0->mList[i_0].type = element_0.type.unsignedIntValue;
                        listHolder_0->mList[i_0].revision = element_0.revision.unsignedShortValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeServerListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::ServerList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClientListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::ClientList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePartsListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::PartsList::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.unsignedShortValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Descriptor::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestDiagnosticLogs ()
@property (readonly) chip::Controller::DiagnosticLogsCluster cppCluster;
@end

@implementation CHIPTestDiagnosticLogs

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DiagnosticLogs::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DiagnosticLogs::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DiagnosticLogs::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DiagnosticLogs::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DiagnosticLogs::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestDoorLock ()
@property (readonly) chip::Controller::DoorLockCluster cppCluster;
@end

@implementation CHIPTestDoorLock

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeLockStateWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::LockState::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLockTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::LockType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActuatorEnabledWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::ActuatorEnabled::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDoorStateWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::DoorState::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfLogRecordsSupportedWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfLogRecordsSupported::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfTotalUsersSupportedWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfTotalUsersSupported::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfPINUsersSupportedWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfPINUsersSupported::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfRFIDUsersSupportedWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfRFIDUsersSupported::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfWeekDaySchedulesSupportedPerUserWithValue:(NSNumber * _Nonnull)value
                                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfWeekDaySchedulesSupportedPerUser::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfYearDaySchedulesSupportedPerUserWithValue:(NSNumber * _Nonnull)value
                                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfYearDaySchedulesSupportedPerUser::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfHolidaySchedulesSupportedWithValue:(NSNumber * _Nonnull)value
                                               completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfHolidaySchedulesSupported::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxPINCodeLengthWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::MaxPINCodeLength::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinPINCodeLengthWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::MinPINCodeLength::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxRFIDCodeLengthWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::MaxRFIDCodeLength::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinRFIDCodeLengthWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::MinRFIDCodeLength::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCredentialRulesSupportWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::CredentialRulesSupport::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfCredentialsSupportedPerUserWithValue:(NSNumber * _Nonnull)value
                                                 completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::NumberOfCredentialsSupportedPerUser::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSupportedOperatingModesWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::SupportedOperatingModes::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDefaultConfigurationRegisterWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::DefaultConfigurationRegister::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = DoorLock::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestElectricalMeasurement ()
@property (readonly) chip::Controller::ElectricalMeasurementCluster cppCluster;
@end

@implementation CHIPTestElectricalMeasurement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMeasurementTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasurementType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcVoltageWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcVoltageMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcVoltageMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcCurrentMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcCurrentMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcPowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcPowerMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcPowerMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcVoltageMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcVoltageDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcVoltageDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcCurrentMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcCurrentDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcCurrentDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcPowerMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDcPowerDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::DcPowerDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcFrequencyWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequency::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcFrequencyMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcFrequencyMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNeutralCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::NeutralCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTotalActivePowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::TotalActivePower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.intValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTotalReactivePowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::TotalReactivePower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.intValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTotalApparentPowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::TotalApparentPower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasured1stHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured1stHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasured3rdHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured3rdHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasured5thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured5thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasured7thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured7thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasured9thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured9thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasured11thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::Measured11thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasuredPhase1stHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase1stHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasuredPhase3rdHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase3rdHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasuredPhase5thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase5thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasuredPhase7thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase7thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasuredPhase9thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase9thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeasuredPhase11thHarmonicCurrentWithValue:(NSNumber * _Nonnull)value
                                              completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::MeasuredPhase11thHarmonicCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcFrequencyMultiplierWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcFrequencyDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcFrequencyDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePowerMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePowerDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeHarmonicCurrentMultiplierWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::HarmonicCurrentMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePhaseHarmonicCurrentMultiplierWithValue:(NSNumber * _Nonnull)value
                                            completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::PhaseHarmonicCurrentMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstantaneousVoltageWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstantaneousLineCurrentWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousLineCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstantaneousActiveCurrentWithValue:(NSNumber * _Nonnull)value
                                        completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousActiveCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstantaneousReactiveCurrentWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousReactiveCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstantaneousPowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::InstantaneousPower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerMinWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMin::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReactivePowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApparentPowerWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPower::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePowerFactorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcVoltageMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcVoltageDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcCurrentMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcCurrentDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcPowerMultiplierWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerMultiplier::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcPowerDivisorWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcPowerDivisor::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeVoltageOverloadWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::VoltageOverload::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentOverloadWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::CurrentOverload::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcVoltageOverloadWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcVoltageOverload::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcCurrentOverloadWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcCurrentOverload::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcActivePowerOverloadWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcActivePowerOverload::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcReactivePowerOverloadWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcReactivePowerOverload::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsOverVoltageWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsUnderVoltageWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeOverVoltageWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeUnderVoltageWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSagWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSag::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSwellWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwell::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLineCurrentPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveCurrentPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReactiveCurrentPhaseBWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltagePhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageMinPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageMaxPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentMinPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentMaxPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerMinPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerMaxPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReactivePowerPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApparentPowerPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePowerFactorPhaseBWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsVoltageMeasurementPeriodPhaseBWithValue:(NSNumber * _Nonnull)value
                                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsOverVoltageCounterPhaseBWithValue:(NSNumber * _Nonnull)value
                                                completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsUnderVoltageCounterPhaseBWithValue:(NSNumber * _Nonnull)value
                                                 completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeOverVoltagePeriodPhaseBWithValue:(NSNumber * _Nonnull)value
                                               completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeUnderVoltagePeriodPhaseBWithValue:(NSNumber * _Nonnull)value
                                                completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSagPeriodPhaseBWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSwellPeriodPhaseBWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseB::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLineCurrentPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::LineCurrentPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveCurrentPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActiveCurrentPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReactiveCurrentPhaseCWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactiveCurrentPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltagePhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltagePhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageMinPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMinPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageMaxPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageMaxPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentMinPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMinPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsCurrentMaxPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsCurrentMaxPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerMinPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMinPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActivePowerMaxPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ActivePowerMaxPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeReactivePowerPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ReactivePowerPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeApparentPowerPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ApparentPowerPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePowerFactorPhaseCWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::PowerFactorPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsVoltageMeasurementPeriodPhaseCWithValue:(NSNumber * _Nonnull)value
                                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsVoltageMeasurementPeriodPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsOverVoltageCounterPhaseCWithValue:(NSNumber * _Nonnull)value
                                                completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsOverVoltageCounterPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAverageRmsUnderVoltageCounterPhaseCWithValue:(NSNumber * _Nonnull)value
                                                 completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AverageRmsUnderVoltageCounterPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeOverVoltagePeriodPhaseCWithValue:(NSNumber * _Nonnull)value
                                               completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeOverVoltagePeriodPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsExtremeUnderVoltagePeriodPhaseCWithValue:(NSNumber * _Nonnull)value
                                                completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsExtremeUnderVoltagePeriodPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSagPeriodPhaseCWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSagPeriodPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRmsVoltageSwellPeriodPhaseCWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::RmsVoltageSwellPeriodPhaseC::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ElectricalMeasurement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestEthernetNetworkDiagnostics ()
@property (readonly) chip::Controller::EthernetNetworkDiagnosticsCluster cppCluster;
@end

@implementation CHIPTestEthernetNetworkDiagnostics

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributePHYRateWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PHYRate::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFullDuplexWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FullDuplex::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.boolValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePacketRxCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketRxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePacketTxCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::PacketTxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxErrCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TxErrCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCollisionCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CollisionCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOverrunCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCarrierDetectWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::CarrierDetect::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.boolValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTimeSinceResetWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::TimeSinceReset::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = EthernetNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestFanControl ()
@property (readonly) chip::Controller::FanControlCluster cppCluster;
@end

@implementation CHIPTestFanControl

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributePercentCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::PercentCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSpeedMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::SpeedMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSpeedCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::SpeedCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRockSupportWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::RockSupport::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWindSupportWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::WindSupport::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FanControl::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestFixedLabel ()
@property (readonly) chip::Controller::FixedLabelCluster cppCluster;
@end

@implementation CHIPTestFixedLabel

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeLabelListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FixedLabel::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:[CHIPFixedLabelClusterLabelStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPFixedLabelClusterLabelStruct *) value[i_0];
                        listHolder_0->mList[i_0].label = [self asCharSpan:element_0.label];
                        listHolder_0->mList[i_0].value = [self asCharSpan:element_0.value];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FixedLabel::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FixedLabel::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FixedLabel::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FixedLabel::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FixedLabel::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestFlowMeasurement ()
@property (readonly) chip::Controller::FlowMeasurementCluster cppCluster;
@end

@implementation CHIPTestFlowMeasurement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::MeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::Tolerance::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = FlowMeasurement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestGeneralCommissioning ()
@property (readonly) chip::Controller::GeneralCommissioningCluster cppCluster;
@end

@implementation CHIPTestGeneralCommissioning

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeBasicCommissioningInfoWithValue:(CHIPGeneralCommissioningClusterBasicCommissioningInfo * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::BasicCommissioningInfo::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue.failSafeExpiryLengthSeconds = value.failSafeExpiryLengthSeconds.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRegulatoryConfigWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::RegulatoryConfig::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLocationCapabilityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::LocationCapability::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSupportsConcurrentConnectionWithValue:(NSNumber * _Nonnull)value
                                          completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::SupportsConcurrentConnection::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralCommissioning::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestGeneralDiagnostics ()
@property (readonly) chip::Controller::GeneralDiagnosticsCluster cppCluster;
@end

@implementation CHIPTestGeneralDiagnostics

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeNetworkInterfacesWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::NetworkInterfaces::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:[CHIPGeneralDiagnosticsClusterNetworkInterfaceType class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPGeneralDiagnosticsClusterNetworkInterfaceType *) value[i_0];
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                        listHolder_0->mList[i_0].isOperational = element_0.isOperational.boolValue;
                        if (element_0.offPremiseServicesReachableIPv4 == nil) {
                            listHolder_0->mList[i_0].offPremiseServicesReachableIPv4.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].offPremiseServicesReachableIPv4.SetNonNull();
                            nonNullValue_2 = element_0.offPremiseServicesReachableIPv4.boolValue;
                        }
                        if (element_0.offPremiseServicesReachableIPv6 == nil) {
                            listHolder_0->mList[i_0].offPremiseServicesReachableIPv6.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].offPremiseServicesReachableIPv6.SetNonNull();
                            nonNullValue_2 = element_0.offPremiseServicesReachableIPv6.boolValue;
                        }
                        listHolder_0->mList[i_0].hardwareAddress = [self asByteSpan:element_0.hardwareAddress];
                        {
                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].IPv4Addresses)>;
                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
                            if (element_0.iPv4Addresses.count != 0) {
                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.iPv4Addresses.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.iPv4Addresses.count; ++i_2) {
                                    if (![element_0.iPv4Addresses[i_2] isKindOfClass:[NSData class]]) {
                                        // Wrong kind of value.
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    auto element_2 = (NSData *) element_0.iPv4Addresses[i_2];
                                    listHolder_2->mList[i_2] = [self asByteSpan:element_2];
                                }
                                listHolder_0->mList[i_0].IPv4Addresses
                                    = ListType_2(listHolder_2->mList, element_0.iPv4Addresses.count);
                            } else {
                                listHolder_0->mList[i_0].IPv4Addresses = ListType_2();
                            }
                        }
                        {
                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].IPv6Addresses)>;
                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
                            if (element_0.iPv6Addresses.count != 0) {
                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.iPv6Addresses.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.iPv6Addresses.count; ++i_2) {
                                    if (![element_0.iPv6Addresses[i_2] isKindOfClass:[NSData class]]) {
                                        // Wrong kind of value.
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    auto element_2 = (NSData *) element_0.iPv6Addresses[i_2];
                                    listHolder_2->mList[i_2] = [self asByteSpan:element_2];
                                }
                                listHolder_0->mList[i_0].IPv6Addresses
                                    = ListType_2(listHolder_2->mList, element_0.iPv6Addresses.count);
                            } else {
                                listHolder_0->mList[i_0].IPv6Addresses = ListType_2();
                            }
                        }
                        listHolder_0->mList[i_0].type
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].type)>>(
                                element_0.type.unsignedCharValue);
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRebootCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::RebootCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUpTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::UpTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTotalOperationalHoursWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::TotalOperationalHours::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBootReasonsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::BootReasons::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveHardwareFaultsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveHardwareFaults::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveRadioFaultsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveRadioFaults::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveNetworkFaultsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::ActiveNetworkFaults::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GeneralDiagnostics::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestGroupKeyManagement ()
@property (readonly) chip::Controller::GroupKeyManagementCluster cppCluster;
@end

@implementation CHIPTestGroupKeyManagement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGroupTableWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::GroupTable::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:[CHIPGroupKeyManagementClusterGroupInfoMapStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPGroupKeyManagementClusterGroupInfoMapStruct *) value[i_0];
                        listHolder_0->mList[i_0].groupId = element_0.groupId.unsignedShortValue;
                        {
                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].endpoints)>;
                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
                            if (element_0.endpoints.count != 0) {
                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.endpoints.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.endpoints.count; ++i_2) {
                                    if (![element_0.endpoints[i_2] isKindOfClass:[NSNumber class]]) {
                                        // Wrong kind of value.
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    auto element_2 = (NSNumber *) element_0.endpoints[i_2];
                                    listHolder_2->mList[i_2] = element_2.unsignedShortValue;
                                }
                                listHolder_0->mList[i_0].endpoints = ListType_2(listHolder_2->mList, element_0.endpoints.count);
                            } else {
                                listHolder_0->mList[i_0].endpoints = ListType_2();
                            }
                        }
                        if (element_0.groupName != nil) {
                            auto & definedValue_2 = listHolder_0->mList[i_0].groupName.Emplace();
                            definedValue_2 = [self asCharSpan:element_0.groupName];
                        }
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxGroupsPerFabricWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupsPerFabric::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxGroupKeysPerFabricWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::MaxGroupKeysPerFabric::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = GroupKeyManagement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestGroups ()
@property (readonly) chip::Controller::GroupsCluster cppCluster;
@end

@implementation CHIPTestGroups

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeNameSupportWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Groups::Attributes::NameSupport::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Groups::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Groups::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Groups::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Groups::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Groups::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestIdentify ()
@property (readonly) chip::Controller::IdentifyCluster cppCluster;
@end

@implementation CHIPTestIdentify

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeIdentifyTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::IdentifyType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Identify::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestIlluminanceMeasurement ()
@property (readonly) chip::Controller::IlluminanceMeasurementCluster cppCluster;
@end

@implementation CHIPTestIlluminanceMeasurement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::MeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::Tolerance::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLightSensorTypeWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::LightSensorType::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = IlluminanceMeasurement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestKeypadInput ()
@property (readonly) chip::Controller::KeypadInputCluster cppCluster;
@end

@implementation CHIPTestKeypadInput

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = KeypadInput::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = KeypadInput::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = KeypadInput::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = KeypadInput::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = KeypadInput::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestLevelControl ()
@property (readonly) chip::Controller::LevelControlCluster cppCluster;
@end

@implementation CHIPTestLevelControl

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeCurrentLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::CurrentLevel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRemainingTimeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::RemainingTime::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::MinLevel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::MaxLevel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentFrequencyWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::CurrentFrequency::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinFrequencyWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::MinFrequency::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxFrequencyWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::MaxFrequency::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LevelControl::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestLocalizationConfiguration ()
@property (readonly) chip::Controller::LocalizationConfigurationCluster cppCluster;
@end

@implementation CHIPTestLocalizationConfiguration

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeSupportedLocalesWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::SupportedLocales::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:[NSString class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSString *) value[i_0];
                        listHolder_0->mList[i_0] = [self asCharSpan:element_0];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LocalizationConfiguration::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestLowPower ()
@property (readonly) chip::Controller::LowPowerCluster cppCluster;
@end

@implementation CHIPTestLowPower

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LowPower::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LowPower::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LowPower::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LowPower::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = LowPower::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestMediaInput ()
@property (readonly) chip::Controller::MediaInputCluster cppCluster;
@end

@implementation CHIPTestMediaInput

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeInputListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::InputList::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:[CHIPMediaInputClusterInputInfo class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPMediaInputClusterInputInfo *) value[i_0];
                        listHolder_0->mList[i_0].index = element_0.index.unsignedCharValue;
                        listHolder_0->mList[i_0].inputType
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].inputType)>>(
                                element_0.inputType.unsignedCharValue);
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                        listHolder_0->mList[i_0].description = [self asCharSpan:element_0.descriptionString];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentInputWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::CurrentInput::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaInput::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestMediaPlayback ()
@property (readonly) chip::Controller::MediaPlaybackCluster cppCluster;
@end

@implementation CHIPTestMediaPlayback

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeCurrentStateWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::CurrentState::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStartTimeWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::StartTime::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDurationWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::Duration::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSampledPositionWithValue:(CHIPMediaPlaybackClusterPlaybackPosition * _Nullable)value
                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::SampledPosition::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0.updatedAt = value.updatedAt.unsignedLongLongValue;
                if (value.position == nil) {
                    nonNullValue_0.position.SetNull();
                } else {
                    auto & nonNullValue_2 = nonNullValue_0.position.SetNonNull();
                    nonNullValue_2 = value.position.unsignedLongLongValue;
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePlaybackSpeedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::PlaybackSpeed::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.floatValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSeekRangeEndWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::SeekRangeEnd::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSeekRangeStartWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::SeekRangeStart::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = MediaPlayback::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestModeSelect ()
@property (readonly) chip::Controller::ModeSelectCluster cppCluster;
@end

@implementation CHIPTestModeSelect

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::Description::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStandardNamespaceWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::StandardNamespace::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSupportedModesWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::SupportedModes::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:[CHIPModeSelectClusterModeOptionStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPModeSelectClusterModeOptionStruct *) value[i_0];
                        listHolder_0->mList[i_0].label = [self asCharSpan:element_0.label];
                        listHolder_0->mList[i_0].mode = element_0.mode.unsignedCharValue;
                        {
                            using ListType_2 = std::remove_reference_t<decltype(listHolder_0->mList[i_0].semanticTags)>;
                            using ListMemberType_2 = ListMemberTypeGetter<ListType_2>::Type;
                            if (element_0.semanticTags.count != 0) {
                                auto * listHolder_2 = new ListHolder<ListMemberType_2>(element_0.semanticTags.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.semanticTags.count; ++i_2) {
                                    if (![element_0.semanticTags[i_2] isKindOfClass:[CHIPModeSelectClusterSemanticTag class]]) {
                                        // Wrong kind of value.
                                        return CHIP_ERROR_INVALID_ARGUMENT;
                                    }
                                    auto element_2 = (CHIPModeSelectClusterSemanticTag *) element_0.semanticTags[i_2];
                                    listHolder_2->mList[i_2].mfgCode = element_2.mfgCode.unsignedShortValue;
                                    listHolder_2->mList[i_2].value = element_2.value.unsignedShortValue;
                                }
                                listHolder_0->mList[i_0].semanticTags
                                    = ListType_2(listHolder_2->mList, element_0.semanticTags.count);
                            } else {
                                listHolder_0->mList[i_0].semanticTags = ListType_2();
                            }
                        }
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::CurrentMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ModeSelect::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestNetworkCommissioning ()
@property (readonly) chip::Controller::NetworkCommissioningCluster cppCluster;
@end

@implementation CHIPTestNetworkCommissioning

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMaxNetworksWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::MaxNetworks::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNetworksWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::Networks::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:[CHIPNetworkCommissioningClusterNetworkInfo class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPNetworkCommissioningClusterNetworkInfo *) value[i_0];
                        listHolder_0->mList[i_0].networkID = [self asByteSpan:element_0.networkID];
                        listHolder_0->mList[i_0].connected = element_0.connected.boolValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeScanMaxTimeSecondsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::ScanMaxTimeSeconds::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeConnectMaxTimeSecondsWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::ConnectMaxTimeSeconds::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLastNetworkingStatusWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkingStatus::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLastNetworkIDWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::LastNetworkID::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = [self asByteSpan:value];
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLastConnectErrorValueWithValue:(NSNumber * _Nullable)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::LastConnectErrorValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.intValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = NetworkCommissioning::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestOtaSoftwareUpdateProvider ()
@property (readonly) chip::Controller::OtaSoftwareUpdateProviderCluster cppCluster;
@end

@implementation CHIPTestOtaSoftwareUpdateProvider

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateProvider::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestOtaSoftwareUpdateRequestor ()
@property (readonly) chip::Controller::OtaSoftwareUpdateRequestorCluster cppCluster;
@end

@implementation CHIPTestOtaSoftwareUpdateRequestor

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeUpdatePossibleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdatePossible::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUpdateStateWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateState::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUpdateStateProgressWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::UpdateStateProgress::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OtaSoftwareUpdateRequestor::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestOccupancySensing ()
@property (readonly) chip::Controller::OccupancySensingCluster cppCluster;
@end

@implementation CHIPTestOccupancySensing

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeOccupancyWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::Occupancy::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupancySensorTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupancySensorTypeBitmapWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::OccupancySensorTypeBitmap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OccupancySensing::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestOnOff ()
@property (readonly) chip::Controller::OnOffCluster cppCluster;
@end

@implementation CHIPTestOnOff

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeOnOffWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::OnOff::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGlobalSceneControlWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::GlobalSceneControl::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOff::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestOnOffSwitchConfiguration ()
@property (readonly) chip::Controller::OnOffSwitchConfigurationCluster cppCluster;
@end

@implementation CHIPTestOnOffSwitchConfiguration

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeSwitchTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::SwitchType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OnOffSwitchConfiguration::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestOperationalCredentials ()
@property (readonly) chip::Controller::OperationalCredentialsCluster cppCluster;
@end

@implementation CHIPTestOperationalCredentials

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeNOCsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::NOCs::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:[CHIPOperationalCredentialsClusterNOCStruct class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPOperationalCredentialsClusterNOCStruct *) value[i_0];
                        listHolder_0->mList[i_0].noc = [self asByteSpan:element_0.noc];
                        if (element_0.icac == nil) {
                            listHolder_0->mList[i_0].icac.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].icac.SetNonNull();
                            nonNullValue_2 = [self asByteSpan:element_0.icac];
                        }
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFabricsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::Fabrics::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:[CHIPOperationalCredentialsClusterFabricDescriptor class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPOperationalCredentialsClusterFabricDescriptor *) value[i_0];
                        listHolder_0->mList[i_0].rootPublicKey = [self asByteSpan:element_0.rootPublicKey];
                        listHolder_0->mList[i_0].vendorId
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0].vendorId)>>(
                                element_0.vendorId.unsignedShortValue);
                        listHolder_0->mList[i_0].fabricId = element_0.fabricId.unsignedLongLongValue;
                        listHolder_0->mList[i_0].nodeId = element_0.nodeId.unsignedLongLongValue;
                        listHolder_0->mList[i_0].label = [self asCharSpan:element_0.label];
                        listHolder_0->mList[i_0].fabricIndex = element_0.fabricIndex.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSupportedFabricsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::SupportedFabrics::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCommissionedFabricsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::CommissionedFabrics::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTrustedRootCertificatesWithValue:(NSArray * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::TrustedRootCertificates::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSData class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSData *) value[i_0];
                        listHolder_0->mList[i_0] = [self asByteSpan:element_0];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentFabricIndexWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::CurrentFabricIndex::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = OperationalCredentials::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestPowerSource ()
@property (readonly) chip::Controller::PowerSourceCluster cppCluster;
@end

@implementation CHIPTestPowerSource

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::Status::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOrderWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::Order::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDescriptionWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::Description::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredAssessedInputVoltageWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredAssessedInputFrequencyWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredAssessedInputFrequency::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredCurrentTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredCurrentType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredAssessedCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredAssessedCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredNominalVoltageWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredNominalVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredMaximumCurrentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredMaximumCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiredPresentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::WiredPresent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveWiredFaultsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::ActiveWiredFaults::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryVoltageWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryVoltage::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryPercentRemainingWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryPercentRemaining::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryTimeRemainingWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryTimeRemaining::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryChargeLevelWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryChargeLevel::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryReplacementNeededWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryReplacementNeeded::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryReplaceabilityWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryReplaceability::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryPresentWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryPresent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveBatteryFaultsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::ActiveBatteryFaults::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryReplacementDescriptionWithValue:(NSString * _Nonnull)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryReplacementDescription::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryCommonDesignationWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryCommonDesignation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryANSIDesignationWithValue:(NSString * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryANSIDesignation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryIECDesignationWithValue:(NSString * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryIECDesignation::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryApprovedChemistryWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryApprovedChemistry::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryCapacityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryCapacity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryQuantityWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryQuantity::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryChargeStateWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryChargeState::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryTimeToFullChargeWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryTimeToFullCharge::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryFunctionalWhileChargingWithValue:(NSNumber * _Nonnull)value
                                            completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryFunctionalWhileCharging::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBatteryChargingCurrentWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::BatteryChargingCurrent::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveBatteryChargeFaultsWithValue:(NSArray * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::ActiveBatteryChargeFaults::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSource::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestPowerSourceConfiguration ()
@property (readonly) chip::Controller::PowerSourceConfigurationCluster cppCluster;
@end

@implementation CHIPTestPowerSourceConfiguration

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeSourcesWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSourceConfiguration::Attributes::Sources::TypeInfo;
            TypeInfo::Type cppValue;
            {
                using ListType_0 = std::remove_reference_t<decltype(cppValue)>;
                using ListMemberType_0 = ListMemberTypeGetter<ListType_0>::Type;
                if (value.count != 0) {
                    auto * listHolder_0 = new ListHolder<ListMemberType_0>(value.count);
                    if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                    }
                    listFreer.add(listHolder_0);
                    for (size_t i_0 = 0; i_0 < value.count; ++i_0) {
                        if (![value[i_0] isKindOfClass:[NSNumber class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (NSNumber *) value[i_0];
                        listHolder_0->mList[i_0] = element_0.unsignedCharValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSourceConfiguration::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSourceConfiguration::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSourceConfiguration::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSourceConfiguration::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PowerSourceConfiguration::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestPressureMeasurement ()
@property (readonly) chip::Controller::PressureMeasurementCluster cppCluster;
@end

@implementation CHIPTestPressureMeasurement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::MeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::Tolerance::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeScaledValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::ScaledValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinScaledValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::MinScaledValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxScaledValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::MaxScaledValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeScaledToleranceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::ScaledTolerance::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeScaleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::Scale::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.charValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PressureMeasurement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestPumpConfigurationAndControl ()
@property (readonly) chip::Controller::PumpConfigurationAndControlCluster cppCluster;
@end

@implementation CHIPTestPumpConfigurationAndControl

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMaxPressureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxPressure::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxSpeedWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxSpeed::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxFlowWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxFlow::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinConstPressureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstPressure::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxConstPressureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstPressure::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinCompPressureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinCompPressure::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxCompPressureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxCompPressure::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinConstSpeedWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstSpeed::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxConstSpeedWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstSpeed::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinConstFlowWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstFlow::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxConstFlowWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstFlow::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinConstTempWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MinConstTemp::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxConstTempWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::MaxConstTemp::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePumpStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::PumpStatus::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedShortValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEffectiveOperationModeWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveOperationMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEffectiveControlModeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::EffectiveControlMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCapacityWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::Capacity::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSpeedWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::Speed::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePowerWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::Power::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedIntValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = PumpConfigurationAndControl::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestRelativeHumidityMeasurement ()
@property (readonly) chip::Controller::RelativeHumidityMeasurementCluster cppCluster;
@end

@implementation CHIPTestRelativeHumidityMeasurement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::Tolerance::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = RelativeHumidityMeasurement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestScenes ()
@property (readonly) chip::Controller::ScenesCluster cppCluster;
@end

@implementation CHIPTestScenes

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeSceneCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::SceneCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentSceneWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::CurrentScene::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentGroupWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::CurrentGroup::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSceneValidWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::SceneValid::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.boolValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNameSupportWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::NameSupport::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLastConfiguredByWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::LastConfiguredBy::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Scenes::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestSoftwareDiagnostics ()
@property (readonly) chip::Controller::SoftwareDiagnosticsCluster cppCluster;
@end

@implementation CHIPTestSoftwareDiagnostics

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeThreadMetricsWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::ThreadMetrics::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:[CHIPSoftwareDiagnosticsClusterThreadMetrics class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPSoftwareDiagnosticsClusterThreadMetrics *) value[i_0];
                        listHolder_0->mList[i_0].id = element_0.id.unsignedLongLongValue;
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                        listHolder_0->mList[i_0].stackFreeCurrent = element_0.stackFreeCurrent.unsignedIntValue;
                        listHolder_0->mList[i_0].stackFreeMinimum = element_0.stackFreeMinimum.unsignedIntValue;
                        listHolder_0->mList[i_0].stackSize = element_0.stackSize.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentHeapFreeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapFree::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentHeapUsedWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapUsed::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentHeapHighWatermarkWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = SoftwareDiagnostics::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestSwitch ()
@property (readonly) chip::Controller::SwitchCluster cppCluster;
@end

@implementation CHIPTestSwitch

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeNumberOfPositionsWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::NumberOfPositions::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::CurrentPosition::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMultiPressMaxWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::MultiPressMax::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Switch::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestTargetNavigator ()
@property (readonly) chip::Controller::TargetNavigatorCluster cppCluster;
@end

@implementation CHIPTestTargetNavigator

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeTargetListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::TargetList::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:[CHIPTargetNavigatorClusterTargetInfo class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPTargetNavigatorClusterTargetInfo *) value[i_0];
                        listHolder_0->mList[i_0].identifier = element_0.identifier.unsignedCharValue;
                        listHolder_0->mList[i_0].name = [self asCharSpan:element_0.name];
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentTargetWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::CurrentTarget::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TargetNavigator::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestTemperatureMeasurement ()
@property (readonly) chip::Controller::TemperatureMeasurementCluster cppCluster;
@end

@implementation CHIPTestTemperatureMeasurement

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::MeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMinMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::MinMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMaxMeasuredValueWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::MaxMeasuredValue::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeToleranceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::Tolerance::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestTestCluster ()
@property (readonly) chip::Controller::TestClusterCluster cppCluster;
@end

@implementation CHIPTestTestCluster

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TestCluster::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestThermostat ()
@property (readonly) chip::Controller::ThermostatCluster cppCluster;
@end

@implementation CHIPTestThermostat

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeLocalTemperatureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::LocalTemperature::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOutdoorTemperatureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::OutdoorTemperature::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupancyWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::Occupancy::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAbsMinHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AbsMinHeatSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAbsMaxHeatSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AbsMaxHeatSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAbsMinCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AbsMinCoolSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAbsMaxCoolSetpointLimitWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AbsMaxCoolSetpointLimit::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.shortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePICoolingDemandWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::PICoolingDemand::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePIHeatingDemandWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::PIHeatingDemand::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAlarmMaskWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AlarmMask::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeThermostatRunningModeWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ThermostatRunningMode::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStartOfWeekWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::StartOfWeek::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfWeeklyTransitionsWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::NumberOfWeeklyTransitions::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfDailyTransitionsWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::NumberOfDailyTransitions::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeThermostatRunningStateWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ThermostatRunningState::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSetpointChangeSourceWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::SetpointChangeSource::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSetpointChangeAmountWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::SetpointChangeAmount::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSetpointChangeSourceTimestampWithValue:(NSNumber * _Nonnull)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::SetpointChangeSourceTimestamp::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupiedSetbackMinWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMin::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOccupiedSetbackMaxWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::OccupiedSetbackMax::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUnoccupiedSetbackMinWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMin::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeUnoccupiedSetbackMaxWithValue:(NSNumber * _Nullable)value
                                  completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::UnoccupiedSetbackMax::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeACCoilTemperatureWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ACCoilTemperature::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.shortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = Thermostat::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestThermostatUserInterfaceConfiguration ()
@property (readonly) chip::Controller::ThermostatUserInterfaceConfigurationCluster cppCluster;
@end

@implementation CHIPTestThermostatUserInterfaceConfiguration

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThermostatUserInterfaceConfiguration::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestThreadNetworkDiagnostics ()
@property (readonly) chip::Controller::ThreadNetworkDiagnosticsCluster cppCluster;
@end

@implementation CHIPTestThreadNetworkDiagnostics

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeChannelWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Channel::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRoutingRoleWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RoutingRole::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNetworkNameWithValue:(NSString * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NetworkName::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = [self asCharSpan:value];
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePanIdWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PanId::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeExtendedPanIdWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ExtendedPanId::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedLongLongValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeMeshLocalPrefixWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::MeshLocalPrefix::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = [self asByteSpan:value];
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOverrunCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNeighborTableListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::NeighborTableList::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:[CHIPThreadNetworkDiagnosticsClusterNeighborTable class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPThreadNetworkDiagnosticsClusterNeighborTable *) value[i_0];
                        listHolder_0->mList[i_0].extAddress = element_0.extAddress.unsignedLongLongValue;
                        listHolder_0->mList[i_0].age = element_0.age.unsignedIntValue;
                        listHolder_0->mList[i_0].rloc16 = element_0.rloc16.unsignedShortValue;
                        listHolder_0->mList[i_0].linkFrameCounter = element_0.linkFrameCounter.unsignedIntValue;
                        listHolder_0->mList[i_0].mleFrameCounter = element_0.mleFrameCounter.unsignedIntValue;
                        listHolder_0->mList[i_0].lqi = element_0.lqi.unsignedCharValue;
                        if (element_0.averageRssi == nil) {
                            listHolder_0->mList[i_0].averageRssi.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].averageRssi.SetNonNull();
                            nonNullValue_2 = element_0.averageRssi.charValue;
                        }
                        if (element_0.lastRssi == nil) {
                            listHolder_0->mList[i_0].lastRssi.SetNull();
                        } else {
                            auto & nonNullValue_2 = listHolder_0->mList[i_0].lastRssi.SetNonNull();
                            nonNullValue_2 = element_0.lastRssi.charValue;
                        }
                        listHolder_0->mList[i_0].frameErrorRate = element_0.frameErrorRate.unsignedCharValue;
                        listHolder_0->mList[i_0].messageErrorRate = element_0.messageErrorRate.unsignedCharValue;
                        listHolder_0->mList[i_0].rxOnWhenIdle = element_0.rxOnWhenIdle.boolValue;
                        listHolder_0->mList[i_0].fullThreadDevice = element_0.fullThreadDevice.boolValue;
                        listHolder_0->mList[i_0].fullNetworkData = element_0.fullNetworkData.boolValue;
                        listHolder_0->mList[i_0].isChild = element_0.isChild.boolValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRouteTableListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouteTableList::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:[CHIPThreadNetworkDiagnosticsClusterRouteTable class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPThreadNetworkDiagnosticsClusterRouteTable *) value[i_0];
                        listHolder_0->mList[i_0].extAddress = element_0.extAddress.unsignedLongLongValue;
                        listHolder_0->mList[i_0].rloc16 = element_0.rloc16.unsignedShortValue;
                        listHolder_0->mList[i_0].routerId = element_0.routerId.unsignedCharValue;
                        listHolder_0->mList[i_0].nextHop = element_0.nextHop.unsignedCharValue;
                        listHolder_0->mList[i_0].pathCost = element_0.pathCost.unsignedCharValue;
                        listHolder_0->mList[i_0].LQIIn = element_0.lqiIn.unsignedCharValue;
                        listHolder_0->mList[i_0].LQIOut = element_0.lqiOut.unsignedCharValue;
                        listHolder_0->mList[i_0].age = element_0.age.unsignedCharValue;
                        listHolder_0->mList[i_0].allocated = element_0.allocated.boolValue;
                        listHolder_0->mList[i_0].linkEstablished = element_0.linkEstablished.boolValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePartitionIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionId::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWeightingWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Weighting::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDataVersionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DataVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeStableDataVersionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::StableDataVersion::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLeaderRouterIdWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRouterId::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDetachedRoleCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::DetachedRoleCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeChildRoleCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChildRoleCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRouterRoleCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RouterRoleCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeLeaderRoleCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::LeaderRoleCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttachAttemptCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttachAttemptCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePartitionIdChangeCountWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PartitionIdChangeCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBetterPartitionAttachAttemptCountWithValue:(NSNumber * _Nonnull)value
                                               completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::BetterPartitionAttachAttemptCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeParentChangeCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ParentChangeCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxTotalCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxTotalCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxUnicastCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxUnicastCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxBroadcastCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxAckRequestedCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxAckedCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxAckedCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxNoAckRequestedCountWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxDataCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxDataPollCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDataPollCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxBeaconCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxBeaconRequestCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxOtherCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxOtherCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxRetryCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxRetryCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxDirectMaxRetryExpiryCountWithValue:(NSNumber * _Nonnull)value
                                         completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxIndirectMaxRetryExpiryCountWithValue:(NSNumber * _Nonnull)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxErrCcaCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxErrAbortCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTxErrBusyChannelCountWithValue:(NSNumber * _Nonnull)value
                                   completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxTotalCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxTotalCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxUnicastCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxUnicastCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxBroadcastCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxDataCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxDataPollCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDataPollCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxBeaconCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxBeaconRequestCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxOtherCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxOtherCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxAddressFilteredCountWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxDestAddrFilteredCountWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxDuplicatedCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxErrNoFrameCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxErrUnknownNeighborCountWithValue:(NSNumber * _Nonnull)value
                                       completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxErrInvalidSrcAddrCountWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxErrSecCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrSecCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxErrFcsCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRxErrOtherCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveTimestampWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveTimestamp::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePendingTimestampWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::PendingTimestamp::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeDelayWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::Delay::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSecurityPolicyWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::SecurityPolicy::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:[CHIPThreadNetworkDiagnosticsClusterSecurityPolicy class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPThreadNetworkDiagnosticsClusterSecurityPolicy *) value[i_0];
                        listHolder_0->mList[i_0].rotationTime = element_0.rotationTime.unsignedShortValue;
                        listHolder_0->mList[i_0].flags = element_0.flags.unsignedShortValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeChannelMaskWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ChannelMask::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asByteSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOperationalDatasetComponentsWithValue:(NSArray * _Nonnull)value
                                          completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::OperationalDatasetComponents::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:[CHIPThreadNetworkDiagnosticsClusterOperationalDatasetComponents class]]) {
                            // Wrong kind of value.
                            return CHIP_ERROR_INVALID_ARGUMENT;
                        }
                        auto element_0 = (CHIPThreadNetworkDiagnosticsClusterOperationalDatasetComponents *) value[i_0];
                        listHolder_0->mList[i_0].activeTimestampPresent = element_0.activeTimestampPresent.boolValue;
                        listHolder_0->mList[i_0].pendingTimestampPresent = element_0.pendingTimestampPresent.boolValue;
                        listHolder_0->mList[i_0].masterKeyPresent = element_0.masterKeyPresent.boolValue;
                        listHolder_0->mList[i_0].networkNamePresent = element_0.networkNamePresent.boolValue;
                        listHolder_0->mList[i_0].extendedPanIdPresent = element_0.extendedPanIdPresent.boolValue;
                        listHolder_0->mList[i_0].meshLocalPrefixPresent = element_0.meshLocalPrefixPresent.boolValue;
                        listHolder_0->mList[i_0].delayPresent = element_0.delayPresent.boolValue;
                        listHolder_0->mList[i_0].panIdPresent = element_0.panIdPresent.boolValue;
                        listHolder_0->mList[i_0].channelPresent = element_0.channelPresent.boolValue;
                        listHolder_0->mList[i_0].pskcPresent = element_0.pskcPresent.boolValue;
                        listHolder_0->mList[i_0].securityPolicyPresent = element_0.securityPolicyPresent.boolValue;
                        listHolder_0->mList[i_0].channelMaskPresent = element_0.channelMaskPresent.boolValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeActiveNetworkFaultsListWithValue:(NSArray * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ActiveNetworkFaultsList::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]
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(element_0.unsignedCharValue);
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = ThreadNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestTimeFormatLocalization ()
@property (readonly) chip::Controller::TimeFormatLocalizationCluster cppCluster;
@end

@implementation CHIPTestTimeFormatLocalization

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeSupportedCalendarTypesWithValue:(NSArray * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::SupportedCalendarTypes::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]
                            = static_cast<std::remove_reference_t<decltype(listHolder_0->mList[i_0])>>(element_0.unsignedCharValue);
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = TimeFormatLocalization::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestUnitLocalization ()
@property (readonly) chip::Controller::UnitLocalizationCluster cppCluster;
@end

@implementation CHIPTestUnitLocalization

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UnitLocalization::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UnitLocalization::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UnitLocalization::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UnitLocalization::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UnitLocalization::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestUserLabel ()
@property (readonly) chip::Controller::UserLabelCluster cppCluster;
@end

@implementation CHIPTestUserLabel

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UserLabel::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UserLabel::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UserLabel::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UserLabel::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = UserLabel::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestWakeOnLan ()
@property (readonly) chip::Controller::WakeOnLanCluster cppCluster;
@end

@implementation CHIPTestWakeOnLan

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeMACAddressWithValue:(NSString * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WakeOnLan::Attributes::MACAddress::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = [self asCharSpan:value];
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WakeOnLan::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WakeOnLan::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WakeOnLan::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WakeOnLan::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WakeOnLan::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestWiFiNetworkDiagnostics ()
@property (readonly) chip::Controller::WiFiNetworkDiagnosticsCluster cppCluster;
@end

@implementation CHIPTestWiFiNetworkDiagnostics

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeBssidWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Bssid::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = [self asByteSpan:value];
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSecurityTypeWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::SecurityType::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeWiFiVersionWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::WiFiVersion::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = static_cast<std::remove_reference_t<decltype(nonNullValue_0)>>(value.unsignedCharValue);
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeChannelNumberWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ChannelNumber::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeRssiWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::Rssi::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.charValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBeaconLostCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconLostCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeBeaconRxCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::BeaconRxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePacketMulticastRxCountWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePacketMulticastTxCountWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePacketUnicastRxCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePacketUnicastTxCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentMaxRateWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOverrunCountWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::OverrunCount::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedLongLongValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WiFiNetworkDiagnostics::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end

@interface CHIPTestWindowCovering ()
@property (readonly) chip::Controller::WindowCoveringCluster cppCluster;
@end

@implementation CHIPTestWindowCovering

- (chip::Controller::ClusterBase *)getCluster
{
    return &_cppCluster;
}

- (void)writeAttributeTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::Type::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePhysicalClosedLimitLiftWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitLift::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributePhysicalClosedLimitTiltWithValue:(NSNumber * _Nonnull)value
                                     completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::PhysicalClosedLimitTilt::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionLiftWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLift::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionTiltWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTilt::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfActuationsLiftWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsLift::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeNumberOfActuationsTiltWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::NumberOfActuationsTilt::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeConfigStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::ConfigStatus::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionLiftPercentageWithValue:(NSNumber * _Nullable)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercentage::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionTiltPercentageWithValue:(NSNumber * _Nullable)value
                                           completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercentage::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedCharValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeOperationalStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::OperationalStatus::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedCharValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTargetPositionLiftPercent100thsWithValue:(NSNumber * _Nullable)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::TargetPositionLiftPercent100ths::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeTargetPositionTiltPercent100thsWithValue:(NSNumber * _Nullable)value
                                             completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::TargetPositionTiltPercent100ths::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeEndProductTypeWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::EndProductType::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = static_cast<std::remove_reference_t<decltype(cppValue)>>(value.unsignedCharValue);
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionLiftPercent100thsWithValue:(NSNumber * _Nullable)value
                                              completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionLiftPercent100ths::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeCurrentPositionTiltPercent100thsWithValue:(NSNumber * _Nullable)value
                                              completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::CurrentPositionTiltPercent100ths::TypeInfo;
            TypeInfo::Type cppValue;
            if (value == nil) {
                cppValue.SetNull();
            } else {
                auto & nonNullValue_0 = cppValue.SetNonNull();
                nonNullValue_0 = value.unsignedShortValue;
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstalledOpenLimitLiftWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitLift::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstalledClosedLimitLiftWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitLift::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstalledOpenLimitTiltWithValue:(NSNumber * _Nonnull)value
                                    completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::InstalledOpenLimitTilt::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeInstalledClosedLimitTiltWithValue:(NSNumber * _Nonnull)value
                                      completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::InstalledClosedLimitTilt::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeSafetyStatusWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::SafetyStatus::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::GeneratedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAcceptedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::AcceptedCommandList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeAttributeListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::AttributeList::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.unsignedIntValue;
                    }
                    cppValue = ListType_0(listHolder_0->mList, value.count);
                } else {
                    cppValue = ListType_0();
                }
            }
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeFeatureMapWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::FeatureMap::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedIntValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

- (void)writeAttributeClusterRevisionWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler
{
    new CHIPDefaultSuccessCallbackBridge(
        self.callbackQueue,
        ^(id _Nullable ignored, NSError * _Nullable error) {
            completionHandler(error);
        },
        ^(Cancelable * success, Cancelable * failure) {
            ListFreer listFreer;
            using TypeInfo = WindowCovering::Attributes::ClusterRevision::TypeInfo;
            TypeInfo::Type cppValue;
            cppValue = value.unsignedShortValue;
            auto successFn = Callback<CHIPDefaultSuccessCallbackType>::FromCancelable(success);
            auto failureFn = Callback<CHIPDefaultFailureCallbackType>::FromCancelable(failure);
            return self.cppCluster.WriteAttribute<TypeInfo>(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall);
        });
}

@end