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

#import "MTRCallbackBridgeBase_internal.h"
#import <Foundation/Foundation.h>

#include <app-common/zap-generated/cluster-objects.h>
#include <app/data-model/DecodableList.h>
#include <app/util/im-client-callbacks.h>

typedef void (*CommandSuccessCallback)(void *, const chip::app::DataModel::NullObjectType &);
using CommandSuccessCallbackType = CommandSuccessCallback;
typedef void (*DefaultSuccessCallbackType)(void *);

typedef void (*VendorIdAttributeCallback)(void *, chip::VendorId);
typedef void (*NullableVendorIdAttributeCallback)(void *, const chip::app::DataModel::Nullable<chip::VendorId> &);

typedef void (*GroupsClusterAddGroupResponseCallbackType)(
    void *, const chip::app::Clusters::Groups::Commands::AddGroupResponse::DecodableType &);
typedef void (*GroupsClusterViewGroupResponseCallbackType)(
    void *, const chip::app::Clusters::Groups::Commands::ViewGroupResponse::DecodableType &);
typedef void (*GroupsClusterGetGroupMembershipResponseCallbackType)(
    void *, const chip::app::Clusters::Groups::Commands::GetGroupMembershipResponse::DecodableType &);
typedef void (*GroupsClusterRemoveGroupResponseCallbackType)(
    void *, const chip::app::Clusters::Groups::Commands::RemoveGroupResponse::DecodableType &);
typedef void (*ScenesClusterAddSceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::AddSceneResponse::DecodableType &);
typedef void (*ScenesClusterViewSceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::ViewSceneResponse::DecodableType &);
typedef void (*ScenesClusterRemoveSceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::RemoveSceneResponse::DecodableType &);
typedef void (*ScenesClusterRemoveAllScenesResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::RemoveAllScenesResponse::DecodableType &);
typedef void (*ScenesClusterStoreSceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::StoreSceneResponse::DecodableType &);
typedef void (*ScenesClusterGetSceneMembershipResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::GetSceneMembershipResponse::DecodableType &);
typedef void (*ScenesClusterEnhancedAddSceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::EnhancedAddSceneResponse::DecodableType &);
typedef void (*ScenesClusterEnhancedViewSceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::EnhancedViewSceneResponse::DecodableType &);
typedef void (*ScenesClusterCopySceneResponseCallbackType)(
    void *, const chip::app::Clusters::Scenes::Commands::CopySceneResponse::DecodableType &);
typedef void (*OTASoftwareUpdateProviderClusterQueryImageResponseCallbackType)(
    void *, const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType &);
typedef void (*OTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackType)(
    void *, const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateResponse::DecodableType &);
typedef void (*GeneralCommissioningClusterArmFailSafeResponseCallbackType)(
    void *, const chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType &);
typedef void (*GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType)(
    void *, const chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfigResponse::DecodableType &);
typedef void (*GeneralCommissioningClusterCommissioningCompleteResponseCallbackType)(
    void *, const chip::app::Clusters::GeneralCommissioning::Commands::CommissioningCompleteResponse::DecodableType &);
typedef void (*NetworkCommissioningClusterScanNetworksResponseCallbackType)(
    void *, const chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworksResponse::DecodableType &);
typedef void (*NetworkCommissioningClusterNetworkConfigResponseCallbackType)(
    void *, const chip::app::Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType &);
typedef void (*NetworkCommissioningClusterConnectNetworkResponseCallbackType)(
    void *, const chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType &);
typedef void (*DiagnosticLogsClusterRetrieveLogsResponseCallbackType)(
    void *, const chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType &);
typedef void (*OperationalCredentialsClusterAttestationResponseCallbackType)(
    void *, const chip::app::Clusters::OperationalCredentials::Commands::AttestationResponse::DecodableType &);
typedef void (*OperationalCredentialsClusterCertificateChainResponseCallbackType)(
    void *, const chip::app::Clusters::OperationalCredentials::Commands::CertificateChainResponse::DecodableType &);
typedef void (*OperationalCredentialsClusterCSRResponseCallbackType)(
    void *, const chip::app::Clusters::OperationalCredentials::Commands::CSRResponse::DecodableType &);
typedef void (*OperationalCredentialsClusterNOCResponseCallbackType)(
    void *, const chip::app::Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType &);
typedef void (*GroupKeyManagementClusterKeySetReadResponseCallbackType)(
    void *, const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadResponse::DecodableType &);
typedef void (*GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType)(
    void *, const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndicesResponse::DecodableType &);
typedef void (*DoorLockClusterGetWeekDayScheduleResponseCallbackType)(
    void *, const chip::app::Clusters::DoorLock::Commands::GetWeekDayScheduleResponse::DecodableType &);
typedef void (*DoorLockClusterGetYearDayScheduleResponseCallbackType)(
    void *, const chip::app::Clusters::DoorLock::Commands::GetYearDayScheduleResponse::DecodableType &);
typedef void (*DoorLockClusterGetHolidayScheduleResponseCallbackType)(
    void *, const chip::app::Clusters::DoorLock::Commands::GetHolidayScheduleResponse::DecodableType &);
typedef void (*DoorLockClusterGetUserResponseCallbackType)(
    void *, const chip::app::Clusters::DoorLock::Commands::GetUserResponse::DecodableType &);
typedef void (*DoorLockClusterSetCredentialResponseCallbackType)(
    void *, const chip::app::Clusters::DoorLock::Commands::SetCredentialResponse::DecodableType &);
typedef void (*DoorLockClusterGetCredentialStatusResponseCallbackType)(
    void *, const chip::app::Clusters::DoorLock::Commands::GetCredentialStatusResponse::DecodableType &);
typedef void (*ThermostatClusterGetWeeklyScheduleResponseCallbackType)(
    void *, const chip::app::Clusters::Thermostat::Commands::GetWeeklyScheduleResponse::DecodableType &);
typedef void (*ChannelClusterChangeChannelResponseCallbackType)(
    void *, const chip::app::Clusters::Channel::Commands::ChangeChannelResponse::DecodableType &);
typedef void (*TargetNavigatorClusterNavigateTargetResponseCallbackType)(
    void *, const chip::app::Clusters::TargetNavigator::Commands::NavigateTargetResponse::DecodableType &);
typedef void (*MediaPlaybackClusterPlaybackResponseCallbackType)(
    void *, const chip::app::Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType &);
typedef void (*KeypadInputClusterSendKeyResponseCallbackType)(
    void *, const chip::app::Clusters::KeypadInput::Commands::SendKeyResponse::DecodableType &);
typedef void (*ContentLauncherClusterLaunchResponseCallbackType)(
    void *, const chip::app::Clusters::ContentLauncher::Commands::LaunchResponse::DecodableType &);
typedef void (*ApplicationLauncherClusterLauncherResponseCallbackType)(
    void *, const chip::app::Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType &);
typedef void (*AccountLoginClusterGetSetupPINResponseCallbackType)(
    void *, const chip::app::Clusters::AccountLogin::Commands::GetSetupPINResponse::DecodableType &);
typedef void (*TestClusterClusterTestSpecificResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestSpecificResponse::DecodableType &);
typedef void (*TestClusterClusterTestAddArgumentsResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType &);
typedef void (*TestClusterClusterTestSimpleArgumentResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestSimpleArgumentResponse::DecodableType &);
typedef void (*TestClusterClusterTestStructArrayArgumentResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestStructArrayArgumentResponse::DecodableType &);
typedef void (*TestClusterClusterTestListInt8UReverseResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseResponse::DecodableType &);
typedef void (*TestClusterClusterTestEnumsResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestEnumsResponse::DecodableType &);
typedef void (*TestClusterClusterTestNullableOptionalResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestNullableOptionalResponse::DecodableType &);
typedef void (*TestClusterClusterTestComplexNullableOptionalResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestComplexNullableOptionalResponse::DecodableType &);
typedef void (*TestClusterClusterBooleanResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType &);
typedef void (*TestClusterClusterSimpleStructResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType &);
typedef void (*TestClusterClusterTestEmitTestEventResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestEmitTestEventResponse::DecodableType &);
typedef void (*TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType)(
    void *, const chip::app::Clusters::TestCluster::Commands::TestEmitTestFabricScopedEventResponse::DecodableType &);

typedef void (*IdentifyClusterIdentifyEffectIdentifierAttributeCallback)(void *,
                                                                         chip::app::Clusters::Identify::IdentifyEffectIdentifier);
typedef void (*NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyEffectIdentifier> &);
typedef void (*IdentifyClusterIdentifyEffectVariantAttributeCallback)(void *, chip::app::Clusters::Identify::IdentifyEffectVariant);
typedef void (*NullableIdentifyClusterIdentifyEffectVariantAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyEffectVariant> &);
typedef void (*IdentifyClusterIdentifyIdentifyTypeAttributeCallback)(void *, chip::app::Clusters::Identify::IdentifyIdentifyType);
typedef void (*NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyIdentifyType> &);
typedef void (*OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback)(
    void *, chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant);
typedef void (*NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant> &);
typedef void (*OnOffClusterOnOffDyingLightEffectVariantAttributeCallback)(void *,
                                                                          chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant);
typedef void (*NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant> &);
typedef void (*OnOffClusterOnOffEffectIdentifierAttributeCallback)(void *, chip::app::Clusters::OnOff::OnOffEffectIdentifier);
typedef void (*NullableOnOffClusterOnOffEffectIdentifierAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffEffectIdentifier> &);
typedef void (*OnOffClusterOnOffStartUpOnOffAttributeCallback)(void *, chip::app::Clusters::OnOff::OnOffStartUpOnOff);
typedef void (*NullableOnOffClusterOnOffStartUpOnOffAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffStartUpOnOff> &);
typedef void (*LevelControlClusterMoveModeAttributeCallback)(void *, chip::app::Clusters::LevelControl::MoveMode);
typedef void (*NullableLevelControlClusterMoveModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::LevelControl::MoveMode> &);
typedef void (*LevelControlClusterStepModeAttributeCallback)(void *, chip::app::Clusters::LevelControl::StepMode);
typedef void (*NullableLevelControlClusterStepModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::LevelControl::StepMode> &);
typedef void (*AccessControlClusterAuthModeAttributeCallback)(void *, chip::app::Clusters::AccessControl::AuthMode);
typedef void (*NullableAccessControlClusterAuthModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::AuthMode> &);
typedef void (*AccessControlClusterChangeTypeEnumAttributeCallback)(void *, chip::app::Clusters::AccessControl::ChangeTypeEnum);
typedef void (*NullableAccessControlClusterChangeTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::ChangeTypeEnum> &);
typedef void (*AccessControlClusterPrivilegeAttributeCallback)(void *, chip::app::Clusters::AccessControl::Privilege);
typedef void (*NullableAccessControlClusterPrivilegeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::Privilege> &);
typedef void (*ActionsClusterActionErrorEnumAttributeCallback)(void *, chip::app::Clusters::Actions::ActionErrorEnum);
typedef void (*NullableActionsClusterActionErrorEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionErrorEnum> &);
typedef void (*ActionsClusterActionStateEnumAttributeCallback)(void *, chip::app::Clusters::Actions::ActionStateEnum);
typedef void (*NullableActionsClusterActionStateEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionStateEnum> &);
typedef void (*ActionsClusterActionTypeEnumAttributeCallback)(void *, chip::app::Clusters::Actions::ActionTypeEnum);
typedef void (*NullableActionsClusterActionTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionTypeEnum> &);
typedef void (*ActionsClusterEndpointListTypeEnumAttributeCallback)(void *, chip::app::Clusters::Actions::EndpointListTypeEnum);
typedef void (*NullableActionsClusterEndpointListTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::EndpointListTypeEnum> &);
typedef void (*OTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback)(
    void *, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction);
typedef void (*NullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction> &);
typedef void (*OTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback)(
    void *, chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol);
typedef void (*NullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol> &);
typedef void (*OTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback)(
    void *, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus);
typedef void (*NullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus> &);
typedef void (*OTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback)(
    void *, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason);
typedef void (*NullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason> &);
typedef void (*OTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback)(
    void *, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum);
typedef void (*NullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum> &);
typedef void (*OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback)(
    void *, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum);
typedef void (*NullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum> &);
typedef void (*TimeFormatLocalizationClusterCalendarTypeAttributeCallback)(
    void *, chip::app::Clusters::TimeFormatLocalization::CalendarType);
typedef void (*NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TimeFormatLocalization::CalendarType> &);
typedef void (*TimeFormatLocalizationClusterHourFormatAttributeCallback)(void *,
                                                                         chip::app::Clusters::TimeFormatLocalization::HourFormat);
typedef void (*NullableTimeFormatLocalizationClusterHourFormatAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TimeFormatLocalization::HourFormat> &);
typedef void (*UnitLocalizationClusterTempUnitAttributeCallback)(void *, chip::app::Clusters::UnitLocalization::TempUnit);
typedef void (*NullableUnitLocalizationClusterTempUnitAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::UnitLocalization::TempUnit> &);
typedef void (*PowerSourceClusterBatChargeFaultAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatChargeFault);
typedef void (*NullablePowerSourceClusterBatChargeFaultAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatChargeFault> &);
typedef void (*PowerSourceClusterBatChargeLevelAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatChargeLevel);
typedef void (*NullablePowerSourceClusterBatChargeLevelAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatChargeLevel> &);
typedef void (*PowerSourceClusterBatChargeStateAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatChargeState);
typedef void (*NullablePowerSourceClusterBatChargeStateAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatChargeState> &);
typedef void (*PowerSourceClusterBatFaultAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatFault);
typedef void (*NullablePowerSourceClusterBatFaultAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatFault> &);
typedef void (*PowerSourceClusterBatReplaceabilityAttributeCallback)(void *, chip::app::Clusters::PowerSource::BatReplaceability);
typedef void (*NullablePowerSourceClusterBatReplaceabilityAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatReplaceability> &);
typedef void (*PowerSourceClusterPowerSourceStatusAttributeCallback)(void *, chip::app::Clusters::PowerSource::PowerSourceStatus);
typedef void (*NullablePowerSourceClusterPowerSourceStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::PowerSourceStatus> &);
typedef void (*PowerSourceClusterWiredCurrentTypeAttributeCallback)(void *, chip::app::Clusters::PowerSource::WiredCurrentType);
typedef void (*NullablePowerSourceClusterWiredCurrentTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::WiredCurrentType> &);
typedef void (*PowerSourceClusterWiredFaultAttributeCallback)(void *, chip::app::Clusters::PowerSource::WiredFault);
typedef void (*NullablePowerSourceClusterWiredFaultAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::WiredFault> &);
typedef void (*GeneralCommissioningClusterCommissioningErrorAttributeCallback)(
    void *, chip::app::Clusters::GeneralCommissioning::CommissioningError);
typedef void (*NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralCommissioning::CommissioningError> &);
typedef void (*GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback)(
    void *, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType);
typedef void (*NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType> &);
typedef void (*NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback)(
    void *, chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus);
typedef void (*NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus> &);
typedef void (*NetworkCommissioningClusterWiFiBandAttributeCallback)(void *, chip::app::Clusters::NetworkCommissioning::WiFiBand);
typedef void (*NullableNetworkCommissioningClusterWiFiBandAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::WiFiBand> &);
typedef void (*DiagnosticLogsClusterLogsIntentAttributeCallback)(void *, chip::app::Clusters::DiagnosticLogs::LogsIntent);
typedef void (*NullableDiagnosticLogsClusterLogsIntentAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DiagnosticLogs::LogsIntent> &);
typedef void (*DiagnosticLogsClusterLogsStatusAttributeCallback)(void *, chip::app::Clusters::DiagnosticLogs::LogsStatus);
typedef void (*NullableDiagnosticLogsClusterLogsStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DiagnosticLogs::LogsStatus> &);
typedef void (*DiagnosticLogsClusterLogsTransferProtocolAttributeCallback)(
    void *, chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol);
typedef void (*NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol> &);
typedef void (*GeneralDiagnosticsClusterBootReasonTypeAttributeCallback)(void *,
                                                                         chip::app::Clusters::GeneralDiagnostics::BootReasonType);
typedef void (*NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::BootReasonType> &);
typedef void (*GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback)(
    void *, chip::app::Clusters::GeneralDiagnostics::HardwareFaultType);
typedef void (*NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::HardwareFaultType> &);
typedef void (*GeneralDiagnosticsClusterInterfaceTypeAttributeCallback)(void *,
                                                                        chip::app::Clusters::GeneralDiagnostics::InterfaceType);
typedef void (*NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::InterfaceType> &);
typedef void (*GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback)(
    void *, chip::app::Clusters::GeneralDiagnostics::NetworkFaultType);
typedef void (*NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::NetworkFaultType> &);
typedef void (*GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback)(void *,
                                                                         chip::app::Clusters::GeneralDiagnostics::RadioFaultType);
typedef void (*NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::RadioFaultType> &);
typedef void (*ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback)(
    void *, chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault);
typedef void (*NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault> &);
typedef void (*ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback)(
    void *, chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole);
typedef void (*NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole> &);
typedef void (*ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback)(
    void *, chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus);
typedef void (*NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus> &);
typedef void (*WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback)(
    void *, chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause);
typedef void (*NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause> &);
typedef void (*WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback)(
    void *, chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType);
typedef void (*NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType> &);
typedef void (*WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback)(
    void *, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus);
typedef void (*NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus> &);
typedef void (*WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback)(
    void *, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType);
typedef void (*NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType> &);
typedef void (*EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback)(
    void *, chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType);
typedef void (*NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType> &);
typedef void (*TimeSynchronizationClusterGranularityEnumAttributeCallback)(
    void *, chip::app::Clusters::TimeSynchronization::GranularityEnum);
typedef void (*NullableTimeSynchronizationClusterGranularityEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::GranularityEnum> &);
typedef void (*TimeSynchronizationClusterTimeSourceEnumAttributeCallback)(void *,
                                                                          chip::app::Clusters::TimeSynchronization::TimeSourceEnum);
typedef void (*NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::TimeSourceEnum> &);
typedef void (*AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback)(
    void *, chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus);
typedef void (*NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus> &);
typedef void (*AdministratorCommissioningClusterStatusCodeAttributeCallback)(
    void *, chip::app::Clusters::AdministratorCommissioning::StatusCode);
typedef void (*NullableAdministratorCommissioningClusterStatusCodeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::AdministratorCommissioning::StatusCode> &);
typedef void (*OperationalCredentialsClusterOperationalCertStatusAttributeCallback)(
    void *, chip::app::Clusters::OperationalCredentials::OperationalCertStatus);
typedef void (*NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::OperationalCredentials::OperationalCertStatus> &);
typedef void (*GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback)(
    void *, chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy);
typedef void (*NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy> &);
typedef void (*DoorLockClusterDlAlarmCodeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlAlarmCode);
typedef void (*NullableDoorLockClusterDlAlarmCodeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlAlarmCode> &);
typedef void (*DoorLockClusterDlCredentialRuleAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlCredentialRule);
typedef void (*NullableDoorLockClusterDlCredentialRuleAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlCredentialRule> &);
typedef void (*DoorLockClusterDlCredentialTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlCredentialType);
typedef void (*NullableDoorLockClusterDlCredentialTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlCredentialType> &);
typedef void (*DoorLockClusterDlDataOperationTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlDataOperationType);
typedef void (*NullableDoorLockClusterDlDataOperationTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlDataOperationType> &);
typedef void (*DoorLockClusterDlDoorStateAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlDoorState);
typedef void (*NullableDoorLockClusterDlDoorStateAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlDoorState> &);
typedef void (*DoorLockClusterDlLockDataTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlLockDataType);
typedef void (*NullableDoorLockClusterDlLockDataTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockDataType> &);
typedef void (*DoorLockClusterDlLockOperationTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlLockOperationType);
typedef void (*NullableDoorLockClusterDlLockOperationTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockOperationType> &);
typedef void (*DoorLockClusterDlLockStateAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlLockState);
typedef void (*NullableDoorLockClusterDlLockStateAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> &);
typedef void (*DoorLockClusterDlLockTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlLockType);
typedef void (*NullableDoorLockClusterDlLockTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockType> &);
typedef void (*DoorLockClusterDlOperatingModeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlOperatingMode);
typedef void (*NullableDoorLockClusterDlOperatingModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlOperatingMode> &);
typedef void (*DoorLockClusterDlOperationErrorAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlOperationError);
typedef void (*NullableDoorLockClusterDlOperationErrorAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlOperationError> &);
typedef void (*DoorLockClusterDlOperationSourceAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlOperationSource);
typedef void (*NullableDoorLockClusterDlOperationSourceAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlOperationSource> &);
typedef void (*DoorLockClusterDlStatusAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlStatus);
typedef void (*NullableDoorLockClusterDlStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlStatus> &);
typedef void (*DoorLockClusterDlUserStatusAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlUserStatus);
typedef void (*NullableDoorLockClusterDlUserStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlUserStatus> &);
typedef void (*DoorLockClusterDlUserTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DlUserType);
typedef void (*NullableDoorLockClusterDlUserTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlUserType> &);
typedef void (*DoorLockClusterDoorLockOperationEventCodeAttributeCallback)(
    void *, chip::app::Clusters::DoorLock::DoorLockOperationEventCode);
typedef void (*NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockOperationEventCode> &);
typedef void (*DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback)(
    void *, chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode);
typedef void (*NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode> &);
typedef void (*DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback)(void *,
                                                                         chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus);
typedef void (*NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus> &);
typedef void (*DoorLockClusterDoorLockUserStatusAttributeCallback)(void *, chip::app::Clusters::DoorLock::DoorLockUserStatus);
typedef void (*NullableDoorLockClusterDoorLockUserStatusAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockUserStatus> &);
typedef void (*DoorLockClusterDoorLockUserTypeAttributeCallback)(void *, chip::app::Clusters::DoorLock::DoorLockUserType);
typedef void (*NullableDoorLockClusterDoorLockUserTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockUserType> &);
typedef void (*WindowCoveringClusterEndProductTypeAttributeCallback)(void *, chip::app::Clusters::WindowCovering::EndProductType);
typedef void (*NullableWindowCoveringClusterEndProductTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::WindowCovering::EndProductType> &);
typedef void (*WindowCoveringClusterTypeAttributeCallback)(void *, chip::app::Clusters::WindowCovering::Type);
typedef void (*NullableWindowCoveringClusterTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::WindowCovering::Type> &);
typedef void (*PumpConfigurationAndControlClusterPumpControlModeAttributeCallback)(
    void *, chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode);
typedef void (*NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode> &);
typedef void (*PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback)(
    void *, chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode);
typedef void (*NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode> &);
typedef void (*ThermostatClusterSetpointAdjustModeAttributeCallback)(void *, chip::app::Clusters::Thermostat::SetpointAdjustMode);
typedef void (*NullableThermostatClusterSetpointAdjustModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::SetpointAdjustMode> &);
typedef void (*ThermostatClusterThermostatControlSequenceAttributeCallback)(
    void *, chip::app::Clusters::Thermostat::ThermostatControlSequence);
typedef void (*NullableThermostatClusterThermostatControlSequenceAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatControlSequence> &);
typedef void (*ThermostatClusterThermostatRunningModeAttributeCallback)(void *,
                                                                        chip::app::Clusters::Thermostat::ThermostatRunningMode);
typedef void (*NullableThermostatClusterThermostatRunningModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatRunningMode> &);
typedef void (*ThermostatClusterThermostatSystemModeAttributeCallback)(void *,
                                                                       chip::app::Clusters::Thermostat::ThermostatSystemMode);
typedef void (*NullableThermostatClusterThermostatSystemModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatSystemMode> &);
typedef void (*FanControlClusterFanModeSequenceTypeAttributeCallback)(void *, chip::app::Clusters::FanControl::FanModeSequenceType);
typedef void (*NullableFanControlClusterFanModeSequenceTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::FanControl::FanModeSequenceType> &);
typedef void (*FanControlClusterFanModeTypeAttributeCallback)(void *, chip::app::Clusters::FanControl::FanModeType);
typedef void (*NullableFanControlClusterFanModeTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::FanControl::FanModeType> &);
typedef void (*ColorControlClusterColorLoopActionAttributeCallback)(void *, chip::app::Clusters::ColorControl::ColorLoopAction);
typedef void (*NullableColorControlClusterColorLoopActionAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorLoopAction> &);
typedef void (*ColorControlClusterColorLoopDirectionAttributeCallback)(void *,
                                                                       chip::app::Clusters::ColorControl::ColorLoopDirection);
typedef void (*NullableColorControlClusterColorLoopDirectionAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorLoopDirection> &);
typedef void (*ColorControlClusterColorModeAttributeCallback)(void *, chip::app::Clusters::ColorControl::ColorMode);
typedef void (*NullableColorControlClusterColorModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorMode> &);
typedef void (*ColorControlClusterHueDirectionAttributeCallback)(void *, chip::app::Clusters::ColorControl::HueDirection);
typedef void (*NullableColorControlClusterHueDirectionAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::HueDirection> &);
typedef void (*ColorControlClusterHueMoveModeAttributeCallback)(void *, chip::app::Clusters::ColorControl::HueMoveMode);
typedef void (*NullableColorControlClusterHueMoveModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::HueMoveMode> &);
typedef void (*ColorControlClusterHueStepModeAttributeCallback)(void *, chip::app::Clusters::ColorControl::HueStepMode);
typedef void (*NullableColorControlClusterHueStepModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::HueStepMode> &);
typedef void (*ColorControlClusterSaturationMoveModeAttributeCallback)(void *,
                                                                       chip::app::Clusters::ColorControl::SaturationMoveMode);
typedef void (*NullableColorControlClusterSaturationMoveModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::SaturationMoveMode> &);
typedef void (*ColorControlClusterSaturationStepModeAttributeCallback)(void *,
                                                                       chip::app::Clusters::ColorControl::SaturationStepMode);
typedef void (*NullableColorControlClusterSaturationStepModeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::SaturationStepMode> &);
typedef void (*IlluminanceMeasurementClusterLightSensorTypeAttributeCallback)(
    void *, chip::app::Clusters::IlluminanceMeasurement::LightSensorType);
typedef void (*NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorType> &);
typedef void (*ChannelClusterChannelStatusEnumAttributeCallback)(void *, chip::app::Clusters::Channel::ChannelStatusEnum);
typedef void (*NullableChannelClusterChannelStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::ChannelStatusEnum> &);
typedef void (*ChannelClusterLineupInfoTypeEnumAttributeCallback)(void *, chip::app::Clusters::Channel::LineupInfoTypeEnum);
typedef void (*NullableChannelClusterLineupInfoTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::LineupInfoTypeEnum> &);
typedef void (*TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback)(
    void *, chip::app::Clusters::TargetNavigator::TargetNavigatorStatusEnum);
typedef void (*NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TargetNavigator::TargetNavigatorStatusEnum> &);
typedef void (*MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback)(
    void *, chip::app::Clusters::MediaPlayback::MediaPlaybackStatusEnum);
typedef void (*NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::MediaPlaybackStatusEnum> &);
typedef void (*MediaPlaybackClusterPlaybackStateEnumAttributeCallback)(void *,
                                                                       chip::app::Clusters::MediaPlayback::PlaybackStateEnum);
typedef void (*NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::PlaybackStateEnum> &);
typedef void (*MediaInputClusterInputTypeEnumAttributeCallback)(void *, chip::app::Clusters::MediaInput::InputTypeEnum);
typedef void (*NullableMediaInputClusterInputTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::MediaInput::InputTypeEnum> &);
typedef void (*KeypadInputClusterCecKeyCodeAttributeCallback)(void *, chip::app::Clusters::KeypadInput::CecKeyCode);
typedef void (*NullableKeypadInputClusterCecKeyCodeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::KeypadInput::CecKeyCode> &);
typedef void (*KeypadInputClusterKeypadInputStatusEnumAttributeCallback)(void *,
                                                                         chip::app::Clusters::KeypadInput::KeypadInputStatusEnum);
typedef void (*NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::KeypadInput::KeypadInputStatusEnum> &);
typedef void (*ContentLauncherClusterContentLaunchStatusEnumAttributeCallback)(
    void *, chip::app::Clusters::ContentLauncher::ContentLaunchStatusEnum);
typedef void (*NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::ContentLaunchStatusEnum> &);
typedef void (*ContentLauncherClusterMetricTypeEnumAttributeCallback)(void *, chip::app::Clusters::ContentLauncher::MetricTypeEnum);
typedef void (*NullableContentLauncherClusterMetricTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::MetricTypeEnum> &);
typedef void (*ContentLauncherClusterParameterEnumAttributeCallback)(void *, chip::app::Clusters::ContentLauncher::ParameterEnum);
typedef void (*NullableContentLauncherClusterParameterEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::ParameterEnum> &);
typedef void (*AudioOutputClusterOutputTypeEnumAttributeCallback)(void *, chip::app::Clusters::AudioOutput::OutputTypeEnum);
typedef void (*NullableAudioOutputClusterOutputTypeEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::AudioOutput::OutputTypeEnum> &);
typedef void (*ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback)(
    void *, chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatusEnum);
typedef void (*NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatusEnum> &);
typedef void (*ApplicationBasicClusterApplicationStatusEnumAttributeCallback)(
    void *, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum);
typedef void (*NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum> &);
typedef void (*TestClusterClusterSimpleEnumAttributeCallback)(void *, chip::app::Clusters::TestCluster::SimpleEnum);
typedef void (*NullableTestClusterClusterSimpleEnumAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::SimpleEnum> &);
typedef void (*FaultInjectionClusterFaultTypeAttributeCallback)(void *, chip::app::Clusters::FaultInjection::FaultType);
typedef void (*NullableFaultInjectionClusterFaultTypeAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::FaultInjection::FaultType> &);

typedef void (*IdentifyGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*IdentifyAcceptedCommandListListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*IdentifyAttributeListListAttributeCallback)(void * context,
                                                           const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*GroupsGeneratedCommandListListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GroupsAcceptedCommandListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GroupsAttributeListListAttributeCallback)(void * context,
                                                         const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ScenesGeneratedCommandListListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ScenesAcceptedCommandListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ScenesAttributeListListAttributeCallback)(void * context,
                                                         const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*OnOffGeneratedCommandListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OnOffAcceptedCommandListListAttributeCallback)(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OnOffAttributeListListAttributeCallback)(void * context,
                                                        const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OnOffSwitchConfigurationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*LevelControlGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*LevelControlAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*LevelControlAttributeListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BinaryInputBasicGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BinaryInputBasicAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BinaryInputBasicAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*DescriptorDeviceTypeListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType> & data);
typedef void (*DescriptorServerListListAttributeCallback)(void * context,
                                                          const chip::app::DataModel::DecodableList<chip::ClusterId> & data);
typedef void (*DescriptorClientListListAttributeCallback)(void * context,
                                                          const chip::app::DataModel::DecodableList<chip::ClusterId> & data);
typedef void (*DescriptorPartsListListAttributeCallback)(void * context,
                                                         const chip::app::DataModel::DecodableList<chip::EndpointId> & data);
typedef void (*DescriptorGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*DescriptorAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*DescriptorAttributeListListAttributeCallback)(void * context,
                                                             const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BindingBindingListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType> & data);
typedef void (*BindingGeneratedCommandListListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BindingAcceptedCommandListListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BindingAttributeListListAttributeCallback)(void * context,
                                                          const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*AccessControlACLListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::AccessControlEntry::DecodableType> &
        data);
typedef void (*AccessControlExtensionListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::ExtensionEntry::DecodableType> & data);
typedef void (*AccessControlGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AccessControlAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AccessControlAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ActionsActionListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType> & data);
typedef void (*ActionsEndpointListsListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType> & data);
typedef void (*ActionsGeneratedCommandListListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ActionsAcceptedCommandListListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ActionsAttributeListListAttributeCallback)(void * context,
                                                          const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BasicCapabilityMinimaStructAttributeCallback)(
    void *, const chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::DecodableType &);
typedef void (*BasicGeneratedCommandListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BasicAcceptedCommandListListAttributeCallback)(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BasicAttributeListListAttributeCallback)(void * context,
                                                        const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OTASoftwareUpdateProviderAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType> & data);
typedef void (*OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OTASoftwareUpdateRequestorAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*LocalizationConfigurationSupportedLocalesListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CharSpan> & data);
typedef void (*LocalizationConfigurationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*LocalizationConfigurationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*LocalizationConfigurationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::app::Clusters::TimeFormatLocalization::CalendarType> & data);
typedef void (*TimeFormatLocalizationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TimeFormatLocalizationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TimeFormatLocalizationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*UnitLocalizationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*UnitLocalizationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*UnitLocalizationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*PowerSourceConfigurationSourcesListAttributeCallback)(void * context,
                                                                     const chip::app::DataModel::DecodableList<uint8_t> & data);
typedef void (*PowerSourceConfigurationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PowerSourceConfigurationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PowerSourceConfigurationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*PowerSourceActiveWiredFaultsListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFault> & data);
typedef void (*PowerSourceActiveBatFaultsListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFault> & data);
typedef void (*PowerSourceActiveBatChargeFaultsListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFault> & data);
typedef void (*PowerSourceGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PowerSourceAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PowerSourceAttributeListListAttributeCallback)(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*GeneralCommissioningBasicCommissioningInfoStructAttributeCallback)(
    void *, const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType &);
typedef void (*GeneralCommissioningGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GeneralCommissioningAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GeneralCommissioningAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*NetworkCommissioningNetworksListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::DecodableType> &
        data);
typedef void (*NetworkCommissioningGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*NetworkCommissioningAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*NetworkCommissioningAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*DiagnosticLogsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*DiagnosticLogsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*DiagnosticLogsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*GeneralDiagnosticsNetworkInterfacesListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType> & data);
typedef void (*GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<uint8_t> & data);
typedef void (*GeneralDiagnosticsActiveRadioFaultsListAttributeCallback)(void * context,
                                                                         const chip::app::DataModel::DecodableList<uint8_t> & data);
typedef void (*GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<uint8_t> & data);
typedef void (*GeneralDiagnosticsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GeneralDiagnosticsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GeneralDiagnosticsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*SoftwareDiagnosticsThreadMetricsListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::DecodableType> &
        data);
typedef void (*SoftwareDiagnosticsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*SoftwareDiagnosticsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*SoftwareDiagnosticsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & data);
typedef void (*ThreadNetworkDiagnosticsRouteTableListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType> &
        data);
typedef void (*ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback)(
    void *,
    const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> &);
typedef void (*ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback)(
    void *,
    const chip::app::DataModel::Nullable<
        chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> &);
typedef void (*ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault> & data);
typedef void (*ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ThreadNetworkDiagnosticsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*WiFiNetworkDiagnosticsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*EthernetNetworkDiagnosticsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BridgedDeviceBasicGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BridgedDeviceBasicAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BridgedDeviceBasicAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*SwitchGeneratedCommandListListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*SwitchAcceptedCommandListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*SwitchAttributeListListAttributeCallback)(void * context,
                                                         const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*AdministratorCommissioningGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AdministratorCommissioningAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AdministratorCommissioningAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*OperationalCredentialsNOCsListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType> &
        data);
typedef void (*OperationalCredentialsFabricsListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & data);
typedef void (*OperationalCredentialsTrustedRootCertificatesListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & data);
typedef void (*OperationalCredentialsGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OperationalCredentialsAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OperationalCredentialsAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*GroupKeyManagementGroupKeyMapListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType> &
        data);
typedef void (*GroupKeyManagementGroupTableListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType> &
        data);
typedef void (*GroupKeyManagementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GroupKeyManagementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*GroupKeyManagementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*FixedLabelLabelListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType> & data);
typedef void (*FixedLabelGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*FixedLabelAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*FixedLabelAttributeListListAttributeCallback)(void * context,
                                                             const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*UserLabelLabelListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType> & data);
typedef void (*UserLabelGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*UserLabelAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*UserLabelAttributeListListAttributeCallback)(void * context,
                                                            const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BooleanStateGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BooleanStateAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BooleanStateAttributeListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ModeSelectSupportedModesListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType> & data);
typedef void (*ModeSelectGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ModeSelectAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ModeSelectAttributeListListAttributeCallback)(void * context,
                                                             const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*DoorLockCredentialRulesSupportAttributeCallback)(void *,
                                                                chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask>);
typedef void (*DoorLockSupportedOperatingModesAttributeCallback)(
    void *, chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes>);
typedef void (*DoorLockDefaultConfigurationRegisterAttributeCallback)(
    void *, chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister>);
typedef void (*DoorLockLocalProgrammingFeaturesAttributeCallback)(
    void *, chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures>);
typedef void (*DoorLockGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*DoorLockAcceptedCommandListListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*DoorLockAttributeListListAttributeCallback)(void * context,
                                                           const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*WindowCoveringConfigStatusAttributeCallback)(void *,
                                                            chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus>);
typedef void (*WindowCoveringOperationalStatusAttributeCallback)(
    void *, chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus>);
typedef void (*WindowCoveringModeAttributeCallback)(void *, chip::BitMask<chip::app::Clusters::WindowCovering::Mode>);
typedef void (*WindowCoveringSafetyStatusAttributeCallback)(void *,
                                                            chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus>);
typedef void (*WindowCoveringGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*WindowCoveringAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*WindowCoveringAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BarrierControlGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BarrierControlAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BarrierControlAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*PumpConfigurationAndControlPumpStatusAttributeCallback)(
    void *, chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatus>);
typedef void (*PumpConfigurationAndControlGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PumpConfigurationAndControlAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PumpConfigurationAndControlAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ThermostatGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ThermostatAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ThermostatAttributeListListAttributeCallback)(void * context,
                                                             const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*FanControlGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*FanControlAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*FanControlAttributeListListAttributeCallback)(void * context,
                                                             const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ColorControlGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ColorControlAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ColorControlAttributeListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*BallastConfigurationGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BallastConfigurationAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*BallastConfigurationAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*IlluminanceMeasurementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*IlluminanceMeasurementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*IlluminanceMeasurementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*TemperatureMeasurementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TemperatureMeasurementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TemperatureMeasurementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*PressureMeasurementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PressureMeasurementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*PressureMeasurementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*FlowMeasurementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*FlowMeasurementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*FlowMeasurementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*RelativeHumidityMeasurementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*OccupancySensingGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OccupancySensingAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*OccupancySensingAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*WakeOnLANGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*WakeOnLANAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*WakeOnLANAttributeListListAttributeCallback)(void * context,
                                                            const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ChannelChannelListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::Channel::Structs::ChannelInfo::DecodableType> & data);
typedef void (*ChannelLineupStructAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfo::DecodableType> &);
typedef void (*ChannelCurrentChannelStructAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::ChannelInfo::DecodableType> &);
typedef void (*ChannelGeneratedCommandListListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ChannelAcceptedCommandListListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ChannelAttributeListListAttributeCallback)(void * context,
                                                          const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*TargetNavigatorTargetListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::TargetNavigator::Structs::TargetInfo::DecodableType> & data);
typedef void (*TargetNavigatorGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TargetNavigatorAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TargetNavigatorAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*MediaPlaybackSampledPositionStructAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::PlaybackPosition::DecodableType> &);
typedef void (*MediaPlaybackGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*MediaPlaybackAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*MediaPlaybackAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*MediaInputInputListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::MediaInput::Structs::InputInfo::DecodableType> & data);
typedef void (*MediaInputGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*MediaInputAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*MediaInputAttributeListListAttributeCallback)(void * context,
                                                             const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*LowPowerGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*LowPowerAcceptedCommandListListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*LowPowerAttributeListListAttributeCallback)(void * context,
                                                           const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*KeypadInputGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*KeypadInputAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*KeypadInputAttributeListListAttributeCallback)(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ContentLauncherAcceptHeaderListAttributeCallback)(void * context,
                                                                 const chip::app::DataModel::DecodableList<chip::CharSpan> & data);
typedef void (*ContentLauncherGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ContentLauncherAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ContentLauncherAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*AudioOutputOutputListListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::AudioOutput::Structs::OutputInfo::DecodableType> & data);
typedef void (*AudioOutputGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AudioOutputAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AudioOutputAttributeListListAttributeCallback)(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ApplicationLauncherCatalogListListAttributeCallback)(void * context,
                                                                    const chip::app::DataModel::DecodableList<uint16_t> & data);
typedef void (*ApplicationLauncherCurrentAppStructAttributeCallback)(
    void *,
    const chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::DecodableType> &);
typedef void (*ApplicationLauncherGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ApplicationLauncherAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ApplicationLauncherAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ApplicationBasicApplicationStructAttributeCallback)(
    void *, const chip::app::Clusters::ApplicationBasic::Structs::ApplicationBasicApplication::DecodableType &);
typedef void (*ApplicationBasicAllowedVendorListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::VendorId> & data);
typedef void (*ApplicationBasicGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ApplicationBasicAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ApplicationBasicAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*AccountLoginGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AccountLoginAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*AccountLoginAttributeListListAttributeCallback)(void * context,
                                                               const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*ElectricalMeasurementGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ElectricalMeasurementAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*ElectricalMeasurementAttributeListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & data);
typedef void (*TestClusterBitmap8AttributeCallback)(void *, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap8MaskMap>);
typedef void (*TestClusterBitmap16AttributeCallback)(void *, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap16MaskMap>);
typedef void (*TestClusterBitmap32AttributeCallback)(void *, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap32MaskMap>);
typedef void (*TestClusterBitmap64AttributeCallback)(void *, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap64MaskMap>);
typedef void (*TestClusterListInt8uListAttributeCallback)(void * context,
                                                          const chip::app::DataModel::DecodableList<uint8_t> & data);
typedef void (*TestClusterListOctetStringListAttributeCallback)(void * context,
                                                                const chip::app::DataModel::DecodableList<chip::ByteSpan> & data);
typedef void (*TestClusterListStructOctetStringListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
        data);
typedef void (*TestClusterListNullablesAndOptionalsStructListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<
        chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & data);
typedef void (*TestClusterStructAttrStructAttributeCallback)(
    void *, const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType &);
typedef void (*TestClusterListLongOctetStringListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & data);
typedef void (*TestClusterListFabricScopedListAttributeCallback)(
    void * context,
    const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestFabricScoped::DecodableType> & data);
typedef void (*TestClusterNullableBitmap8AttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap8MaskMap>> &);
typedef void (*TestClusterNullableBitmap16AttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap16MaskMap>> &);
typedef void (*TestClusterNullableBitmap32AttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap32MaskMap>> &);
typedef void (*TestClusterNullableBitmap64AttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap64MaskMap>> &);
typedef void (*TestClusterNullableStructStructAttributeCallback)(
    void *, const chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType> &);
typedef void (*TestClusterGeneratedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TestClusterAcceptedCommandListListAttributeCallback)(
    void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & data);
typedef void (*TestClusterAttributeListListAttributeCallback)(void * context,
                                                              const chip::app::DataModel::DecodableList<chip::AttributeId> & data);

class MTRDefaultSuccessCallbackBridge : public MTRCallbackBridge<DefaultSuccessCallback>
{
public:
    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<DefaultSuccessCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DefaultSuccessCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRDefaultSuccessCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<DefaultSuccessCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context);
};

class MTRCommandSuccessCallbackBridge : public MTRCallbackBridge<CommandSuccessCallback>
{
public:
    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<CommandSuccessCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<CommandSuccessCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRCommandSuccessCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<CommandSuccessCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::NullObjectType &);
};

class MTROctetStringAttributeCallbackBridge : public MTRCallbackBridge<OctetStringAttributeCallback>
{
public:
    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                          bool keepAlive = false) :
        MTRCallbackBridge<OctetStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                          ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OctetStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTROctetStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OctetStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::ByteSpan value);
};

class MTROctetStringAttributeCallbackSubscriptionBridge : public MTROctetStringAttributeCallbackBridge
{
public:
    MTROctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action,
                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROctetStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROctetStringAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOctetStringAttributeCallbackBridge : public MTRCallbackBridge<NullableOctetStringAttributeCallback>
{
public:
    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                keepAlive){};

    MTRNullableOctetStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOctetStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::ByteSpan> & value);
};

class MTRNullableOctetStringAttributeCallbackSubscriptionBridge : public MTRNullableOctetStringAttributeCallbackBridge
{
public:
    MTRNullableOctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOctetStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOctetStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOctetStringAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRCharStringAttributeCallbackBridge : public MTRCallbackBridge<CharStringAttributeCallback>
{
public:
    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                         bool keepAlive = false) :
        MTRCallbackBridge<CharStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                         ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<CharStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRCharStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<CharStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::CharSpan value);
};

class MTRCharStringAttributeCallbackSubscriptionBridge : public MTRCharStringAttributeCallbackBridge
{
public:
    MTRCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                     ResponseHandler handler, MTRActionBlock action,
                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRCharStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                     MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRCharStringAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableCharStringAttributeCallbackBridge : public MTRCallbackBridge<NullableCharStringAttributeCallback>
{
public:
    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                               keepAlive){};

    MTRNullableCharStringAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableCharStringAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::CharSpan> & value);
};

class MTRNullableCharStringAttributeCallbackSubscriptionBridge : public MTRNullableCharStringAttributeCallbackBridge
{
public:
    MTRNullableCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableCharStringAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableCharStringAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableCharStringAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBooleanAttributeCallbackBridge : public MTRCallbackBridge<BooleanAttributeCallback>
{
public:
    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                      bool keepAlive = false) :
        MTRCallbackBridge<BooleanAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRBooleanAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, bool value);
};

class MTRBooleanAttributeCallbackSubscriptionBridge : public MTRBooleanAttributeCallbackBridge
{
public:
    MTRBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                  ResponseHandler handler, MTRActionBlock action,
                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                  MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableBooleanAttributeCallbackBridge : public MTRCallbackBridge<NullableBooleanAttributeCallback>
{
public:
    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                              ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableBooleanAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableBooleanAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<bool> & value);
};

class MTRNullableBooleanAttributeCallbackSubscriptionBridge : public MTRNullableBooleanAttributeCallbackBridge
{
public:
    MTRNullableBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableBooleanAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableBooleanAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action,
                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableBooleanAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt8uAttributeCallbackBridge : public MTRCallbackBridge<Int8uAttributeCallback>
{
public:
    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<Int8uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int8uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt8uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<Int8uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, uint8_t value);
};

class MTRInt8uAttributeCallbackSubscriptionBridge : public MTRInt8uAttributeCallbackBridge
{
public:
    MTRInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                ResponseHandler handler, MTRActionBlock action,
                                                MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt8uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt8uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt8uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt8uAttributeCallback>
{
public:
    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                            ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt8uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt8uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint8_t> & value);
};

class MTRNullableInt8uAttributeCallbackSubscriptionBridge : public MTRNullableInt8uAttributeCallbackBridge
{
public:
    MTRNullableInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action,
                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt8uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt8uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action,
                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt8uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt8sAttributeCallbackBridge : public MTRCallbackBridge<Int8sAttributeCallback>
{
public:
    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<Int8sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int8sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt8sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<Int8sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, int8_t value);
};

class MTRInt8sAttributeCallbackSubscriptionBridge : public MTRInt8sAttributeCallbackBridge
{
public:
    MTRInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                ResponseHandler handler, MTRActionBlock action,
                                                MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt8sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt8sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt8sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt8sAttributeCallback>
{
public:
    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                            ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt8sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt8sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int8_t> & value);
};

class MTRNullableInt8sAttributeCallbackSubscriptionBridge : public MTRNullableInt8sAttributeCallbackBridge
{
public:
    MTRNullableInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action,
                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt8sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt8sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action,
                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt8sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt16uAttributeCallbackBridge : public MTRCallbackBridge<Int16uAttributeCallback>
{
public:
    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int16uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int16uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt16uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int16uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, uint16_t value);
};

class MTRInt16uAttributeCallbackSubscriptionBridge : public MTRInt16uAttributeCallbackBridge
{
public:
    MTRInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt16uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt16uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt16uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt16uAttributeCallback>
{
public:
    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt16uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt16uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint16_t> & value);
};

class MTRNullableInt16uAttributeCallbackSubscriptionBridge : public MTRNullableInt16uAttributeCallbackBridge
{
public:
    MTRNullableInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt16uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt16uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt16uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt16sAttributeCallbackBridge : public MTRCallbackBridge<Int16sAttributeCallback>
{
public:
    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int16sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int16sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt16sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int16sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, int16_t value);
};

class MTRInt16sAttributeCallbackSubscriptionBridge : public MTRInt16sAttributeCallbackBridge
{
public:
    MTRInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt16sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt16sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt16sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt16sAttributeCallback>
{
public:
    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt16sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt16sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int16_t> & value);
};

class MTRNullableInt16sAttributeCallbackSubscriptionBridge : public MTRNullableInt16sAttributeCallbackBridge
{
public:
    MTRNullableInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt16sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt16sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt16sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt32uAttributeCallbackBridge : public MTRCallbackBridge<Int32uAttributeCallback>
{
public:
    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int32uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int32uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt32uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int32uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, uint32_t value);
};

class MTRInt32uAttributeCallbackSubscriptionBridge : public MTRInt32uAttributeCallbackBridge
{
public:
    MTRInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt32uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt32uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt32uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt32uAttributeCallback>
{
public:
    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt32uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt32uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint32_t> & value);
};

class MTRNullableInt32uAttributeCallbackSubscriptionBridge : public MTRNullableInt32uAttributeCallbackBridge
{
public:
    MTRNullableInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt32uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt32uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt32uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt32sAttributeCallbackBridge : public MTRCallbackBridge<Int32sAttributeCallback>
{
public:
    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int32sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int32sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt32sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int32sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, int32_t value);
};

class MTRInt32sAttributeCallbackSubscriptionBridge : public MTRInt32sAttributeCallbackBridge
{
public:
    MTRInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt32sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt32sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt32sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt32sAttributeCallback>
{
public:
    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt32sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt32sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int32_t> & value);
};

class MTRNullableInt32sAttributeCallbackSubscriptionBridge : public MTRNullableInt32sAttributeCallbackBridge
{
public:
    MTRNullableInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt32sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt32sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt32sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt64uAttributeCallbackBridge : public MTRCallbackBridge<Int64uAttributeCallback>
{
public:
    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int64uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int64uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt64uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int64uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, uint64_t value);
};

class MTRInt64uAttributeCallbackSubscriptionBridge : public MTRInt64uAttributeCallbackBridge
{
public:
    MTRInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt64uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt64uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt64uAttributeCallbackBridge : public MTRCallbackBridge<NullableInt64uAttributeCallback>
{
public:
    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt64uAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt64uAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<uint64_t> & value);
};

class MTRNullableInt64uAttributeCallbackSubscriptionBridge : public MTRNullableInt64uAttributeCallbackBridge
{
public:
    MTRNullableInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt64uAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt64uAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt64uAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRInt64sAttributeCallbackBridge : public MTRCallbackBridge<Int64sAttributeCallback>
{
public:
    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int64sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<Int64sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRInt64sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<Int64sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, int64_t value);
};

class MTRInt64sAttributeCallbackSubscriptionBridge : public MTRInt64sAttributeCallbackBridge
{
public:
    MTRInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt64sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRInt64sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableInt64sAttributeCallbackBridge : public MTRCallbackBridge<NullableInt64sAttributeCallback>
{
public:
    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableInt64sAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableInt64sAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<int64_t> & value);
};

class MTRNullableInt64sAttributeCallbackSubscriptionBridge : public MTRNullableInt64sAttributeCallbackBridge
{
public:
    MTRNullableInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt64sAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableInt64sAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableInt64sAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFloatAttributeCallbackBridge : public MTRCallbackBridge<FloatAttributeCallback>
{
public:
    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<FloatAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FloatAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRFloatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                    bool keepAlive = false) :
        MTRCallbackBridge<FloatAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, float value);
};

class MTRFloatAttributeCallbackSubscriptionBridge : public MTRFloatAttributeCallbackBridge
{
public:
    MTRFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                ResponseHandler handler, MTRActionBlock action,
                                                MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFloatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFloatAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableFloatAttributeCallbackBridge : public MTRCallbackBridge<NullableFloatAttributeCallback>
{
public:
    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableFloatAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                            ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFloatAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableFloatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFloatAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<float> & value);
};

class MTRNullableFloatAttributeCallbackSubscriptionBridge : public MTRNullableFloatAttributeCallbackBridge
{
public:
    MTRNullableFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action,
                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFloatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableFloatAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action,
                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFloatAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoubleAttributeCallbackBridge : public MTRCallbackBridge<DoubleAttributeCallback>
{
public:
    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<DoubleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoubleAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRDoubleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
                                     bool keepAlive = false) :
        MTRCallbackBridge<DoubleAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, double value);
};

class MTRDoubleAttributeCallbackSubscriptionBridge : public MTRDoubleAttributeCallbackBridge
{
public:
    MTRDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action,
                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoubleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoubleAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoubleAttributeCallbackBridge : public MTRCallbackBridge<NullableDoubleAttributeCallback>
{
public:
    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                             ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoubleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoubleAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<double> & value);
};

class MTRNullableDoubleAttributeCallbackSubscriptionBridge : public MTRNullableDoubleAttributeCallbackBridge
{
public:
    MTRNullableDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoubleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoubleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action,
                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoubleAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRVendorIdAttributeCallbackBridge : public MTRCallbackBridge<VendorIdAttributeCallback>
{
public:
    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                       bool keepAlive = false) :
        MTRCallbackBridge<VendorIdAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                       ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<VendorIdAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRVendorIdAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<VendorIdAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::VendorId value);
};

class MTRVendorIdAttributeCallbackSubscriptionBridge : public MTRVendorIdAttributeCallbackBridge
{
public:
    MTRVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                   ResponseHandler handler, MTRActionBlock action,
                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRVendorIdAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                   MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRVendorIdAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableVendorIdAttributeCallbackBridge : public MTRCallbackBridge<NullableVendorIdAttributeCallback>
{
public:
    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                               bool keepAlive = false) :
        MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                               ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableVendorIdAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableVendorIdAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::VendorId> & value);
};

class MTRNullableVendorIdAttributeCallbackSubscriptionBridge : public MTRNullableVendorIdAttributeCallbackBridge
{
public:
    MTRNullableVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action,
                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableVendorIdAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableVendorIdAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action,
                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableVendorIdAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIdentifyGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>
{
public:
    MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<IdentifyGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRIdentifyGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIdentifyGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIdentifyAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>
{
public:
    MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<IdentifyAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRIdentifyAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIdentifyAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIdentifyAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>
{
public:
    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRIdentifyAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge : public MTRIdentifyAttributeListListAttributeCallbackBridge
{
public:
    MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIdentifyAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>
{
public:
    MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRGroupsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<GroupsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGroupsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>
{
public:
    MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRGroupsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGroupsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupsAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<GroupsAttributeListListAttributeCallback>
{
public:
    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRGroupsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge : public MTRGroupsAttributeListListAttributeCallbackBridge
{
public:
    MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRScenesGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>
{
public:
    MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRScenesGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<ScenesGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRScenesGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRScenesGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRScenesGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRScenesAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>
{
public:
    MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRScenesAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRScenesAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRScenesAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRScenesAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRScenesAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ScenesAttributeListListAttributeCallback>
{
public:
    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRScenesAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRScenesAttributeListListAttributeCallbackSubscriptionBridge : public MTRScenesAttributeListListAttributeCallbackBridge
{
public:
    MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRScenesAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRScenesAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRScenesAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>
{
public:
    MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTROnOffGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROnOffGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>
{
public:
    MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTROnOffAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROnOffAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<OnOffAttributeListListAttributeCallback>
{
public:
    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                     bool keepAlive = false) :
        MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                   keepAlive){};

    MTROnOffAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTROnOffAttributeListListAttributeCallbackSubscriptionBridge : public MTROnOffAttributeListListAttributeCallbackBridge
{
public:
    MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>
{
public:
    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffSwitchConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>
{
public:
    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffSwitchConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>
{
public:
    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<OnOffSwitchConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge
{
public:
    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffSwitchConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffSwitchConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLevelControlGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>
{
public:
    MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<LevelControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRLevelControlGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLevelControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLevelControlAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>
{
public:
    MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<LevelControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRLevelControlAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLevelControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLevelControlAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>
{
public:
    MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRLevelControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRLevelControlAttributeListListAttributeCallbackBridge
{
public:
    MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLevelControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>
{
public:
    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBinaryInputBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>
{
public:
    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBinaryInputBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBinaryInputBasicAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>
{
public:
    MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<BinaryInputBasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRBinaryInputBasicAttributeListListAttributeCallbackBridge
{
public:
    MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBinaryInputBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBinaryInputBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorDeviceTypeListListAttributeCallbackBridge
    : public MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>
{
public:
    MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRDescriptorDeviceTypeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorDeviceTypeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::Descriptor::Structs::DeviceTypeStruct::DecodableType> &
            value);
};

class MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge
    : public MTRDescriptorDeviceTypeListListAttributeCallbackBridge
{
public:
    MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorDeviceTypeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorDeviceTypeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorServerListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorServerListListAttributeCallback>
{
public:
    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRDescriptorServerListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorServerListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ClusterId> & value);
};

class MTRDescriptorServerListListAttributeCallbackSubscriptionBridge : public MTRDescriptorServerListListAttributeCallbackBridge
{
public:
    MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorServerListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorServerListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorServerListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorClientListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorClientListListAttributeCallback>
{
public:
    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRDescriptorClientListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorClientListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ClusterId> & value);
};

class MTRDescriptorClientListListAttributeCallbackSubscriptionBridge : public MTRDescriptorClientListListAttributeCallbackBridge
{
public:
    MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorClientListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorClientListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorClientListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorPartsListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorPartsListListAttributeCallback>
{
public:
    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRDescriptorPartsListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorPartsListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::EndpointId> & value);
};

class MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge : public MTRDescriptorPartsListListAttributeCallbackBridge
{
public:
    MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorPartsListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorPartsListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorPartsListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>
{
public:
    MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<DescriptorGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRDescriptorGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>
{
public:
    MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<DescriptorAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRDescriptorAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDescriptorAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>
{
public:
    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRDescriptorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DescriptorAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRDescriptorAttributeListListAttributeCallbackBridge
{
public:
    MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDescriptorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDescriptorAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBindingBindingListAttributeCallbackBridge : public MTRCallbackBridge<BindingBindingListAttributeCallback>
{
public:
    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                 bool keepAlive = false) :
        MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                               keepAlive){};

    MTRBindingBindingListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingBindingListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::Binding::Structs::TargetStruct::DecodableType> & value);
};

class MTRBindingBindingListAttributeCallbackSubscriptionBridge : public MTRBindingBindingListAttributeCallbackBridge
{
public:
    MTRBindingBindingListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingBindingListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBindingBindingListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingBindingListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBindingGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>
{
public:
    MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRBindingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<BindingGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBindingGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBindingGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBindingAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>
{
public:
    MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRBindingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<BindingAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBindingAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBindingAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBindingAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<BindingAttributeListListAttributeCallback>
{
public:
    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRBindingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BindingAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBindingAttributeListListAttributeCallbackSubscriptionBridge : public MTRBindingAttributeListListAttributeCallbackBridge
{
public:
    MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBindingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBindingAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlACLListAttributeCallbackBridge : public MTRCallbackBridge<AccessControlACLListAttributeCallback>
{
public:
    MTRAccessControlACLListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                   bool keepAlive = false) :
        MTRCallbackBridge<AccessControlACLListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlACLListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                   ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlACLListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                 keepAlive){};

    MTRAccessControlACLListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlACLListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::AccessControlEntry::DecodableType> &
            value);
};

class MTRAccessControlACLListAttributeCallbackSubscriptionBridge : public MTRAccessControlACLListAttributeCallbackBridge
{
public:
    MTRAccessControlACLListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlACLListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlACLListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlACLListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlExtensionListAttributeCallbackBridge : public MTRCallbackBridge<AccessControlExtensionListAttributeCallback>
{
public:
    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRAccessControlExtensionListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlExtensionListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::AccessControl::Structs::ExtensionEntry::DecodableType> &
            value);
};

class MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge : public MTRAccessControlExtensionListAttributeCallbackBridge
{
public:
    MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlExtensionListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlExtensionListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlExtensionListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>
{
public:
    MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<AccessControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAccessControlGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>
{
public:
    MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<AccessControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAccessControlAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>
{
public:
    MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRAccessControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<AccessControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRAccessControlAttributeListListAttributeCallbackBridge
{
public:
    MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsActionListListAttributeCallbackBridge : public MTRCallbackBridge<ActionsActionListListAttributeCallback>
{
public:
    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                    bool keepAlive = false) :
        MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                  keepAlive){};

    MTRActionsActionListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsActionListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::ActionStruct::DecodableType> & value);
};

class MTRActionsActionListListAttributeCallbackSubscriptionBridge : public MTRActionsActionListListAttributeCallbackBridge
{
public:
    MTRActionsActionListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action,
                                                                MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsActionListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsActionListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsActionListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsEndpointListsListAttributeCallbackBridge : public MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>
{
public:
    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRActionsEndpointListsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsEndpointListsListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::Actions::Structs::EndpointListStruct::DecodableType> &
            value);
};

class MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge : public MTRActionsEndpointListsListAttributeCallbackBridge
{
public:
    MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsEndpointListsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsEndpointListsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsEndpointListsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>
{
public:
    MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRActionsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<ActionsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRActionsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>
{
public:
    MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRActionsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<ActionsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRActionsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ActionsAttributeListListAttributeCallback>
{
public:
    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRActionsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRActionsAttributeListListAttributeCallbackSubscriptionBridge : public MTRActionsAttributeListListAttributeCallbackBridge
{
public:
    MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBasicCapabilityMinimaStructAttributeCallbackBridge : public MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>
{
public:
    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRBasicCapabilityMinimaStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicCapabilityMinimaStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Basic::Structs::CapabilityMinimaStruct::DecodableType & value);
};

class MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge
    : public MTRBasicCapabilityMinimaStructAttributeCallbackBridge
{
public:
    MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBasicCapabilityMinimaStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicCapabilityMinimaStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBasicGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>
{
public:
    MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBasicGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBasicAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>
{
public:
    MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBasicAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBasicAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<BasicAttributeListListAttributeCallback>
{
public:
    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                     bool keepAlive = false) :
        MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                   keepAlive){};

    MTRBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBasicAttributeListListAttributeCallbackSubscriptionBridge : public MTRBasicAttributeListListAttributeCallbackBridge
{
public:
    MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>
{
public:
    MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>
{
public:
    MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderAttributeListListAttributeCallback>
{
public:
    MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::DecodableType> & value);
};

class MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorDefaultOtaProvidersListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge
    : public MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>
{
public:
    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationSupportedLocalesListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CharSpan> & value);
};

class MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge
    : public MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge
{
public:
    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationSupportedLocalesListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>
{
public:
    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>
{
public:
    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>
{
public:
    MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<LocalizationConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge
{
public:
    MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLocalizationConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLocalizationConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge
    : public MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>
{
public:
    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationSupportedCalendarTypesListAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::DecodableList<chip::app::Clusters::TimeFormatLocalization::CalendarType> & value);
};

class MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge
    : public MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge
{
public:
    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationSupportedCalendarTypesListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>
{
public:
    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>
{
public:
    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>
{
public:
    MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge
{
public:
    MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeFormatLocalizationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>
{
public:
    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUnitLocalizationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>
{
public:
    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUnitLocalizationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUnitLocalizationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>
{
public:
    MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRUnitLocalizationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRUnitLocalizationAttributeListListAttributeCallbackBridge
{
public:
    MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUnitLocalizationAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>
{
public:
    MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationSourcesListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
};

class MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge
{
public:
    MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceConfigurationSourcesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationSourcesListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>
{
public:
    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>
{
public:
    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>
{
public:
    MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge
{
public:
    MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>
{
public:
    MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveWiredFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::WiredFault> & value);
};

class MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge
{
public:
    MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceActiveWiredFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceActiveWiredFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>
{
public:
    MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveBatFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatFault> & value);
};

class MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge
{
public:
    MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceActiveBatFaultsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceActiveBatFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>
{
public:
    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceActiveBatChargeFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<chip::app::Clusters::PowerSource::BatChargeFault> & value);
};

class MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge
{
public:
    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceActiveBatChargeFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>
{
public:
    MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>
{
public:
    MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>
{
public:
    MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRPowerSourceAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceAttributeListListAttributeCallbackBridge
{
public:
    MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>
{
public:
    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningBasicCommissioningInfoStructAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::GeneralCommissioning::Structs::BasicCommissioningInfo::DecodableType & value);
};

class MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge
    : public MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge
{
public:
    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningBasicCommissioningInfoStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>
{
public:
    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>
{
public:
    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralCommissioningAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>
{
public:
    MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRGeneralCommissioningAttributeListListAttributeCallbackBridge
{
public:
    MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNetworkCommissioningNetworksListAttributeCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>
{
public:
    MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningNetworksListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningNetworksListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::NetworkCommissioning::Structs::NetworkInfo::DecodableType> &
            value);
};

class MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge
    : public MTRNetworkCommissioningNetworksListAttributeCallbackBridge
{
public:
    MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNetworkCommissioningNetworksListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningNetworksListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>
{
public:
    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>
{
public:
    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNetworkCommissioningAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>
{
public:
    MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRNetworkCommissioningAttributeListListAttributeCallbackBridge
{
public:
    MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNetworkCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>
{
public:
    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>
{
public:
    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDiagnosticLogsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>
{
public:
    MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRDiagnosticLogsAttributeListListAttributeCallbackBridge
{
public:
    MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDiagnosticLogsAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsNetworkInterfacesListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::GeneralDiagnostics::Structs::NetworkInterfaceType::DecodableType> & value);
};

class MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsNetworkInterfacesListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveHardwareFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
};

class MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsActiveHardwareFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveRadioFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
};

class MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsActiveRadioFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsActiveNetworkFaultsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
};

class MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsActiveNetworkFaultsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>
{
public:
    MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge
    : public MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>
{
public:
    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsThreadMetricsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::SoftwareDiagnostics::Structs::ThreadMetrics::DecodableType> &
            value);
};

class MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge
    : public MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge
{
public:
    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsThreadMetricsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>
{
public:
    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>
{
public:
    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>
{
public:
    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<SoftwareDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge
{
public:
    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSoftwareDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSoftwareDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsNeighborTableListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::ThreadNetworkDiagnostics::Structs::NeighborTable::DecodableType> & value);
};

class MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsNeighborTableListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsRouteTableListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::ThreadNetworkDiagnostics::Structs::RouteTable::DecodableType> & value);
};

class MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsRouteTableListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<
                                chip::app::Clusters::ThreadNetworkDiagnostics::Structs::SecurityPolicy::DecodableType> & value);
};

class MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsSecurityPolicyStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
                                                                                         MTRLocalActionBlock action,
                                                                                         bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(queue, handler, action,
                                                                                                       OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<
                    chip::app::Clusters::ThreadNetworkDiagnostics::Structs::OperationalDatasetComponents::DecodableType> & value);
};

class MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                             action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsOperationalDatasetComponentsStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::DecodableList<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault> & value);
};

class MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsActiveNetworkFaultsListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>
{
public:
    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>
{
public:
    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>
{
public:
    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge
{
public:
    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>
{
public:
    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBridgedDeviceBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>
{
public:
    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBridgedDeviceBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>
{
public:
    MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<BridgedDeviceBasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge
{
public:
    MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBridgedDeviceBasicAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBridgedDeviceBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSwitchGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>
{
public:
    MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRSwitchGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<SwitchGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRSwitchGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSwitchGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSwitchGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSwitchAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>
{
public:
    MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRSwitchAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRSwitchAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSwitchAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSwitchAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRSwitchAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<SwitchAttributeListListAttributeCallback>
{
public:
    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRSwitchAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<SwitchAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge : public MTRSwitchAttributeListListAttributeCallbackBridge
{
public:
    MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSwitchAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRSwitchAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRSwitchAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>
{
public:
    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>
{
public:
    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>
{
public:
    MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge
{
public:
    MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAdministratorCommissioningAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsNOCsListAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>
{
public:
    MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTROperationalCredentialsNOCsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsNOCsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::OperationalCredentials::Structs::NOCStruct::DecodableType> &
            value);
};

class MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsNOCsListAttributeCallbackBridge
{
public:
    MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsNOCsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsNOCsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsFabricsListAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>
{
public:
    MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTROperationalCredentialsFabricsListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsFabricsListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::OperationalCredentials::Structs::FabricDescriptor::DecodableType> & value);
};

class MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsFabricsListAttributeCallbackBridge
{
public:
    MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsFabricsListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsFabricsListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>
{
public:
    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsTrustedRootCertificatesListAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & value);
};

class MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge
{
public:
    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsTrustedRootCertificatesListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>
{
public:
    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>
{
public:
    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>
{
public:
    MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTROperationalCredentialsAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsAttributeListListAttributeCallbackBridge
{
public:
    MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>
{
public:
    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGroupKeyMapListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::DecodableType> & value);
};

class MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge
    : public MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge
{
public:
    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupKeyManagementGroupKeyMapListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementGroupKeyMapListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupKeyManagementGroupTableListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>
{
public:
    MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGroupTableListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::GroupKeyManagement::Structs::GroupInfoMapStruct::DecodableType> & value);
};

class MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge
    : public MTRGroupKeyManagementGroupTableListAttributeCallbackBridge
{
public:
    MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupKeyManagementGroupTableListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementGroupTableListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>
{
public:
    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>
{
public:
    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupKeyManagementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>
{
public:
    MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRGroupKeyManagementAttributeListListAttributeCallbackBridge
{
public:
    MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupKeyManagementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFixedLabelLabelListListAttributeCallbackBridge : public MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>
{
public:
    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRFixedLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelLabelListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::FixedLabel::Structs::LabelStruct::DecodableType> & value);
};

class MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge : public MTRFixedLabelLabelListListAttributeCallbackBridge
{
public:
    MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelLabelListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFixedLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelLabelListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>
{
public:
    MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFixedLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>
{
public:
    MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFixedLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFixedLabelAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>
{
public:
    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRFixedLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FixedLabelAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRFixedLabelAttributeListListAttributeCallbackBridge
{
public:
    MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFixedLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFixedLabelAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUserLabelLabelListListAttributeCallbackBridge : public MTRCallbackBridge<UserLabelLabelListListAttributeCallback>
{
public:
    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                     bool keepAlive = false) :
        MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                   keepAlive){};

    MTRUserLabelLabelListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelLabelListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::UserLabel::Structs::LabelStruct::DecodableType> & value);
};

class MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge : public MTRUserLabelLabelListListAttributeCallbackBridge
{
public:
    MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelLabelListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUserLabelLabelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelLabelListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUserLabelGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>
{
public:
    MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<UserLabelGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRUserLabelGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUserLabelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUserLabelAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>
{
public:
    MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<UserLabelAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRUserLabelAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUserLabelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUserLabelAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>
{
public:
    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRUserLabelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UserLabelAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge : public MTRUserLabelAttributeListListAttributeCallbackBridge
{
public:
    MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUserLabelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUserLabelAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>
{
public:
    MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBooleanStateGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanStateGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>
{
public:
    MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBooleanStateAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanStateAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBooleanStateAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>
{
public:
    MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRBooleanStateAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BooleanStateAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRBooleanStateAttributeListListAttributeCallbackBridge
{
public:
    MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBooleanStateAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBooleanStateAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRModeSelectSupportedModesListAttributeCallbackBridge
    : public MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>
{
public:
    MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRModeSelectSupportedModesListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectSupportedModesListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::ModeSelect::Structs::ModeOptionStruct::DecodableType> &
            value);
};

class MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge
    : public MTRModeSelectSupportedModesListAttributeCallbackBridge
{
public:
    MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRModeSelectSupportedModesListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectSupportedModesListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRModeSelectGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>
{
public:
    MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRModeSelectGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRModeSelectGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRModeSelectAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>
{
public:
    MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRModeSelectAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRModeSelectAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRModeSelectAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>
{
public:
    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRModeSelectAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ModeSelectAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRModeSelectAttributeListListAttributeCallbackBridge
{
public:
    MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRModeSelectAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRModeSelectAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockCredentialRulesSupportAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>
{
public:
    MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<DoorLockCredentialRulesSupportAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlCredentialRuleMask> value);
};

class MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge
    : public MTRDoorLockCredentialRulesSupportAttributeCallbackBridge
{
public:
    MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockCredentialRulesSupportAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockCredentialRulesSupportAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockSupportedOperatingModesAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>
{
public:
    MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DoorLockSupportedOperatingModesAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlSupportedOperatingModes> value);
};

class MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge
    : public MTRDoorLockSupportedOperatingModesAttributeCallbackBridge
{
public:
    MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockSupportedOperatingModesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockSupportedOperatingModesAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>
{
public:
    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<DoorLockDefaultConfigurationRegisterAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlDefaultConfigurationRegister> value);
};

class MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge
    : public MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge
{
public:
    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockDefaultConfigurationRegisterAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockDefaultConfigurationRegisterAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>
{
public:
    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DoorLockLocalProgrammingFeaturesAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::DoorLock::DlLocalProgrammingFeatures> value);
};

class MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge
    : public MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge
{
public:
    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockLocalProgrammingFeaturesAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockLocalProgrammingFeaturesAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>
{
public:
    MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DoorLockGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRDoorLockGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>
{
public:
    MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DoorLockAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRDoorLockAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>
{
public:
    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRDoorLockAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge : public MTRDoorLockAttributeListListAttributeCallbackBridge
{
public:
    MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringConfigStatusAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>
{
public:
    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRWindowCoveringConfigStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringConfigStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::ConfigStatus> value);
};

class MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge : public MTRWindowCoveringConfigStatusAttributeCallbackBridge
{
public:
    MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringConfigStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringConfigStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringOperationalStatusAttributeCallbackBridge
    : public MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>
{
public:
    MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRWindowCoveringOperationalStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringOperationalStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::OperationalStatus> value);
};

class MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge
    : public MTRWindowCoveringOperationalStatusAttributeCallbackBridge
{
public:
    MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringOperationalStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringOperationalStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringModeAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringModeAttributeCallback>
{
public:
    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                 bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                               keepAlive){};

    MTRWindowCoveringModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::Mode> value);
};

class MTRWindowCoveringModeAttributeCallbackSubscriptionBridge : public MTRWindowCoveringModeAttributeCallbackBridge
{
public:
    MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringSafetyStatusAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>
{
public:
    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRWindowCoveringSafetyStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringSafetyStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::WindowCovering::SafetyStatus> value);
};

class MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge : public MTRWindowCoveringSafetyStatusAttributeCallbackBridge
{
public:
    MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringSafetyStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringSafetyStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>
{
public:
    MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>
{
public:
    MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>
{
public:
    MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRWindowCoveringAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRWindowCoveringAttributeListListAttributeCallbackBridge
{
public:
    MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>
{
public:
    MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBarrierControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBarrierControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>
{
public:
    MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBarrierControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBarrierControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBarrierControlAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>
{
public:
    MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRBarrierControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<BarrierControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRBarrierControlAttributeListListAttributeCallbackBridge
{
public:
    MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBarrierControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBarrierControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge
    : public MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>
{
public:
    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlPumpStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::PumpConfigurationAndControl::PumpStatus> value);
};

class MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge
    : public MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge
{
public:
    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPumpConfigurationAndControlPumpStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlPumpStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>
{
public:
    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>
{
public:
    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>
{
public:
    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlAttributeListListAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge
{
public:
    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPumpConfigurationAndControlAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>
{
public:
    MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRThermostatGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<ThermostatGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRThermostatGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>
{
public:
    MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRThermostatAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<ThermostatAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRThermostatAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>
{
public:
    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRThermostatAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRThermostatAttributeListListAttributeCallbackBridge
{
public:
    MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFanControlGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>
{
public:
    MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRFanControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<FanControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRFanControlGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFanControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFanControlAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>
{
public:
    MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRFanControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<FanControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRFanControlAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFanControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFanControlAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<FanControlAttributeListListAttributeCallback>
{
public:
    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRFanControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRFanControlAttributeListListAttributeCallbackBridge
{
public:
    MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFanControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>
{
public:
    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
                                                                                           MTRLocalActionBlock action,
                                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};

    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                               action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatUserInterfaceConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action,
                                                                                               true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>
{
public:
    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
                                                                                          MTRLocalActionBlock action,
                                                                                          bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};

    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                              action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatUserInterfaceConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>
{
public:
    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                    MTRLocalActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                    MTRDeviceController * controller,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThermostatUserInterfaceConfigurationAttributeListListAttributeCallback>(queue, device, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge
{
public:
    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                        true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatUserInterfaceConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>
{
public:
    MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRColorControlGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<ColorControlGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRColorControlGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>
{
public:
    MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRColorControlAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ColorControlAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRColorControlAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>
{
public:
    MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRColorControlAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRColorControlAttributeListListAttributeCallbackBridge
{
public:
    MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>
{
public:
    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBallastConfigurationGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBallastConfigurationGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>
{
public:
    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBallastConfigurationAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBallastConfigurationAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRBallastConfigurationAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>
{
public:
    MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRBallastConfigurationAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<BallastConfigurationAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRBallastConfigurationAttributeListListAttributeCallbackBridge
{
public:
    MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRBallastConfigurationAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRBallastConfigurationAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>
{
public:
    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>
{
public:
    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>
{
public:
    MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge
{
public:
    MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIlluminanceMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>
{
public:
    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTemperatureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>
{
public:
    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTemperatureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>
{
public:
    MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<TemperatureMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge
{
public:
    MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTemperatureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTemperatureMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>
{
public:
    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPressureMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPressureMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>
{
public:
    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPressureMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPressureMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPressureMeasurementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>
{
public:
    MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRPressureMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<PressureMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRPressureMeasurementAttributeListListAttributeCallbackBridge
{
public:
    MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPressureMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPressureMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>
{
public:
    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFlowMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFlowMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>
{
public:
    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFlowMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFlowMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFlowMeasurementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>
{
public:
    MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRFlowMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<FlowMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRFlowMeasurementAttributeListListAttributeCallbackBridge
{
public:
    MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFlowMeasurementAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFlowMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>
{
public:
    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRRelativeHumidityMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>
{
public:
    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRRelativeHumidityMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>
{
public:
    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<RelativeHumidityMeasurementAttributeListListAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge
{
public:
    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRRelativeHumidityMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>
{
public:
    MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROccupancySensingGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROccupancySensingGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>
{
public:
    MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROccupancySensingAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROccupancySensingAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROccupancySensingAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>
{
public:
    MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTROccupancySensingAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<OccupancySensingAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge
    : public MTROccupancySensingAttributeListListAttributeCallbackBridge
{
public:
    MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROccupancySensingAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROccupancySensingAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<WakeOnLANGeneratedCommandListListAttributeCallback>
{
public:
    MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRWakeOnLANGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRWakeOnLANGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWakeOnLANGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWakeOnLANGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<WakeOnLANAcceptedCommandListListAttributeCallback>
{
public:
    MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRWakeOnLANAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRWakeOnLANAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWakeOnLANAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWakeOnLANAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWakeOnLANAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<WakeOnLANAttributeListListAttributeCallback>
{
public:
    MTRWakeOnLANAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWakeOnLANAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRWakeOnLANAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WakeOnLANAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRWakeOnLANAttributeListListAttributeCallbackSubscriptionBridge : public MTRWakeOnLANAttributeListListAttributeCallbackBridge
{
public:
    MTRWakeOnLANAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWakeOnLANAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWakeOnLANAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWakeOnLANAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelChannelListListAttributeCallbackBridge : public MTRCallbackBridge<ChannelChannelListListAttributeCallback>
{
public:
    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                     bool keepAlive = false) :
        MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                   keepAlive){};

    MTRChannelChannelListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelChannelListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::Channel::Structs::ChannelInfo::DecodableType> & value);
};

class MTRChannelChannelListListAttributeCallbackSubscriptionBridge : public MTRChannelChannelListListAttributeCallbackBridge
{
public:
    MTRChannelChannelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelChannelListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelChannelListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelChannelListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelLineupStructAttributeCallbackBridge : public MTRCallbackBridge<ChannelLineupStructAttributeCallback>
{
public:
    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                  bool keepAlive = false) :
        MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                keepAlive){};

    MTRChannelLineupStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelLineupStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::LineupInfo::DecodableType> & value);
};

class MTRChannelLineupStructAttributeCallbackSubscriptionBridge : public MTRChannelLineupStructAttributeCallbackBridge
{
public:
    MTRChannelLineupStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelLineupStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelLineupStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelLineupStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelCurrentChannelStructAttributeCallbackBridge : public MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>
{
public:
    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRChannelCurrentChannelStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelCurrentChannelStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::Structs::ChannelInfo::DecodableType> & value);
};

class MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge
    : public MTRChannelCurrentChannelStructAttributeCallbackBridge
{
public:
    MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelCurrentChannelStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelCurrentChannelStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>
{
public:
    MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRChannelGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<ChannelGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRChannelGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>
{
public:
    MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRChannelAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<ChannelAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRChannelAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<ChannelAttributeListListAttributeCallback>
{
public:
    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRChannelAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRChannelAttributeListListAttributeCallbackSubscriptionBridge : public MTRChannelAttributeListListAttributeCallbackBridge
{
public:
    MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTargetNavigatorTargetListListAttributeCallbackBridge
    : public MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>
{
public:
    MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRTargetNavigatorTargetListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorTargetListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::TargetNavigator::Structs::TargetInfo::DecodableType> &
            value);
};

class MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge
    : public MTRTargetNavigatorTargetListListAttributeCallbackBridge
{
public:
    MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTargetNavigatorTargetListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorTargetListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>
{
public:
    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTargetNavigatorGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>
{
public:
    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTargetNavigatorAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTargetNavigatorAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>
{
public:
    MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRTargetNavigatorAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRTargetNavigatorAttributeListListAttributeCallbackBridge
{
public:
    MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTargetNavigatorAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>
{
public:
    MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackSampledPositionStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::Structs::PlaybackPosition::DecodableType> & value);
};

class MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge
    : public MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge
{
public:
    MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaPlaybackSampledPositionStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackSampledPositionStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>
{
public:
    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaPlaybackGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>
{
public:
    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaPlaybackAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaPlaybackAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>
{
public:
    MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRMediaPlaybackAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRMediaPlaybackAttributeListListAttributeCallbackBridge
{
public:
    MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaPlaybackAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaInputInputListListAttributeCallbackBridge : public MTRCallbackBridge<MediaInputInputListListAttributeCallback>
{
public:
    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRMediaInputInputListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputInputListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::MediaInput::Structs::InputInfo::DecodableType> & value);
};

class MTRMediaInputInputListListAttributeCallbackSubscriptionBridge : public MTRMediaInputInputListListAttributeCallbackBridge
{
public:
    MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputInputListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaInputInputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputInputListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaInputGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>
{
public:
    MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<MediaInputGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRMediaInputGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaInputAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>
{
public:
    MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<MediaInputAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRMediaInputAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaInputAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>
{
public:
    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRMediaInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRMediaInputAttributeListListAttributeCallbackBridge
{
public:
    MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLowPowerGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>
{
public:
    MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<LowPowerGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRLowPowerGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLowPowerGeneratedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLowPowerGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLowPowerAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>
{
public:
    MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<LowPowerAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRLowPowerAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLowPowerAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLowPowerAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLowPowerAttributeListListAttributeCallbackBridge : public MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>
{
public:
    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRLowPowerAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LowPowerAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge : public MTRLowPowerAttributeListListAttributeCallbackBridge
{
public:
    MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLowPowerAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLowPowerAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLowPowerAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>
{
public:
    MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRKeypadInputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>
{
public:
    MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRKeypadInputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRKeypadInputAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>
{
public:
    MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRKeypadInputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRKeypadInputAttributeListListAttributeCallbackBridge
{
public:
    MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRKeypadInputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherAcceptHeaderListAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>
{
public:
    MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAcceptHeaderListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CharSpan> & value);
};

class MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherAcceptHeaderListAttributeCallbackBridge
{
public:
    MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherAcceptHeaderListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherAcceptHeaderListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>
{
public:
    MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>
{
public:
    MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>
{
public:
    MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRContentLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherAttributeListListAttributeCallbackBridge
{
public:
    MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAudioOutputOutputListListAttributeCallbackBridge : public MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>
{
public:
    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRAudioOutputOutputListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputOutputListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::AudioOutput::Structs::OutputInfo::DecodableType> & value);
};

class MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge : public MTRAudioOutputOutputListListAttributeCallbackBridge
{
public:
    MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputOutputListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAudioOutputOutputListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputOutputListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>
{
public:
    MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAudioOutputGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>
{
public:
    MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAudioOutputAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAudioOutputAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>
{
public:
    MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRAudioOutputAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRAudioOutputAttributeListListAttributeCallbackBridge
{
public:
    MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAudioOutputAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationLauncherCatalogListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>
{
public:
    MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRApplicationLauncherCatalogListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherCatalogListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint16_t> & value);
};

class MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationLauncherCatalogListListAttributeCallbackBridge
{
public:
    MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationLauncherCatalogListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherCatalogListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>
{
public:
    MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherCurrentAppStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::DecodableType> &
            value);
};

class MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge
    : public MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge
{
public:
    MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationLauncherCurrentAppStructAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherCurrentAppStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>
{
public:
    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationLauncherGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>
{
public:
    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationLauncherAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationLauncherAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>
{
public:
    MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRApplicationLauncherAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationLauncherAttributeListListAttributeCallbackBridge
{
public:
    MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationLauncherAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationBasicApplicationStructAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>
{
public:
    MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRApplicationBasicApplicationStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicApplicationStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::ApplicationBasic::Structs::ApplicationBasicApplication::DecodableType & value);
};

class MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge
    : public MTRApplicationBasicApplicationStructAttributeCallbackBridge
{
public:
    MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationBasicApplicationStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicApplicationStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>
{
public:
    MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAllowedVendorListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::VendorId> & value);
};

class MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge
{
public:
    MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationBasicAllowedVendorListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicAllowedVendorListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>
{
public:
    MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationBasicGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>
{
public:
    MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationBasicAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationBasicAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>
{
public:
    MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRApplicationBasicAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRApplicationBasicAttributeListListAttributeCallbackBridge
{
public:
    MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationBasicAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>
{
public:
    MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccountLoginGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccountLoginGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>
{
public:
    MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccountLoginAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccountLoginAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccountLoginAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>
{
public:
    MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRAccountLoginAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRAccountLoginAttributeListListAttributeCallbackBridge
{
public:
    MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccountLoginAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccountLoginAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>
{
public:
    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementGeneratedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRElectricalMeasurementGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>
{
public:
    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementAcceptedCommandListListAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRElectricalMeasurementAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRElectricalMeasurementAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>
{
public:
    MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<ElectricalMeasurementAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRElectricalMeasurementAttributeListListAttributeCallbackBridge
{
public:
    MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRElectricalMeasurementAttributeListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRElectricalMeasurementAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterBitmap8AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap8AttributeCallback>
{
public:
    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                 bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                 ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                               keepAlive){};

    MTRTestClusterBitmap8AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap8AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap8MaskMap> value);
};

class MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap8AttributeCallbackBridge
{
public:
    MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap8AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap8AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterBitmap16AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap16AttributeCallback>
{
public:
    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                  bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                keepAlive){};

    MTRTestClusterBitmap16AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap16AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap16MaskMap> value);
};

class MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap16AttributeCallbackBridge
{
public:
    MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap16AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap16AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterBitmap32AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap32AttributeCallback>
{
public:
    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                  bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                keepAlive){};

    MTRTestClusterBitmap32AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap32AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap32MaskMap> value);
};

class MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap32AttributeCallbackBridge
{
public:
    MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap32AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap32AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterBitmap64AttributeCallbackBridge : public MTRCallbackBridge<TestClusterBitmap64AttributeCallback>
{
public:
    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                  bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                  ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                keepAlive){};

    MTRTestClusterBitmap64AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterBitmap64AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::BitMask<chip::app::Clusters::TestCluster::Bitmap64MaskMap> value);
};

class MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge : public MTRTestClusterBitmap64AttributeCallbackBridge
{
public:
    MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap64AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterBitmap64AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterListInt8uListAttributeCallbackBridge : public MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>
{
public:
    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRTestClusterListInt8uListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListInt8uListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<uint8_t> & value);
};

class MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge : public MTRTestClusterListInt8uListAttributeCallbackBridge
{
public:
    MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListInt8uListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterListInt8uListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListInt8uListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterListOctetStringListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>
{
public:
    MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRTestClusterListOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListOctetStringListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & value);
};

class MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterListOctetStringListAttributeCallbackBridge
{
public:
    MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterListOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListOctetStringListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterListStructOctetStringListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>
{
public:
    MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRTestClusterListStructOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListStructOctetStringListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType> &
            value);
};

class MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterListStructOctetStringListAttributeCallbackBridge
{
public:
    MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterListStructOctetStringListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListStructOctetStringListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>
{
public:
    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListNullablesAndOptionalsStructListAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::DecodableList<
                                chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & value);
};

class MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge
{
public:
    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListNullablesAndOptionalsStructListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterStructAttrStructAttributeCallbackBridge : public MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>
{
public:
    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRTestClusterStructAttrStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterStructAttrStructAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & value);
};

class MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge
    : public MTRTestClusterStructAttrStructAttributeCallbackBridge
{
public:
    MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterStructAttrStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterStructAttrStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterListLongOctetStringListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>
{
public:
    MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRTestClusterListLongOctetStringListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListLongOctetStringListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::ByteSpan> & value);
};

class MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterListLongOctetStringListAttributeCallbackBridge
{
public:
    MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterListLongOctetStringListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListLongOctetStringListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterListFabricScopedListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>
{
public:
    MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRTestClusterListFabricScopedListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<TestClusterListFabricScopedListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::DecodableList<chip::app::Clusters::TestCluster::Structs::TestFabricScoped::DecodableType> &
            value);
};

class MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterListFabricScopedListAttributeCallbackBridge
{
public:
    MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterListFabricScopedListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterListFabricScopedListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterNullableBitmap8AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>
{
public:
    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRTestClusterNullableBitmap8AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap8AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap8MaskMap>> & value);
};

class MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge : public MTRTestClusterNullableBitmap8AttributeCallbackBridge
{
public:
    MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterNullableBitmap8AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap8AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterNullableBitmap16AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>
{
public:
    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRTestClusterNullableBitmap16AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap16AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap16MaskMap>> & value);
};

class MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge
    : public MTRTestClusterNullableBitmap16AttributeCallbackBridge
{
public:
    MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterNullableBitmap16AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap16AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterNullableBitmap32AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>
{
public:
    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRTestClusterNullableBitmap32AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap32AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap32MaskMap>> & value);
};

class MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge
    : public MTRTestClusterNullableBitmap32AttributeCallbackBridge
{
public:
    MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterNullableBitmap32AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap32AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterNullableBitmap64AttributeCallbackBridge : public MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>
{
public:
    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRTestClusterNullableBitmap64AttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableBitmap64AttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::BitMask<chip::app::Clusters::TestCluster::Bitmap64MaskMap>> & value);
};

class MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge
    : public MTRTestClusterNullableBitmap64AttributeCallbackBridge
{
public:
    MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterNullableBitmap64AttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableBitmap64AttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterNullableStructStructAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>
{
public:
    MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRTestClusterNullableStructStructAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<TestClusterNullableStructStructAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType> & value);
};

class MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge
    : public MTRTestClusterNullableStructStructAttributeCallbackBridge
{
public:
    MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterNullableStructStructAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterNullableStructStructAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterGeneratedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>
{
public:
    MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<TestClusterGeneratedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterGeneratedCommandListListAttributeCallbackBridge
{
public:
    MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterGeneratedCommandListListAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterGeneratedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterAcceptedCommandListListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>
{
public:
    MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<TestClusterAcceptedCommandListListAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::CommandId> & value);
};

class MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterAcceptedCommandListListAttributeCallbackBridge
{
public:
    MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterAcceptedCommandListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterAcceptedCommandListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterAttributeListListAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>
{
public:
    MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRTestClusterAttributeListListAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterAttributeListListAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::DecodableList<chip::AttributeId> & value);
};

class MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge
    : public MTRTestClusterAttributeListListAttributeCallbackBridge
{
public:
    MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterAttributeListListAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterAttributeListListAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterAttributeListListAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupsClusterAddGroupResponseCallbackBridge : public MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>
{
public:
    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                   bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                   ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRGroupsClusterAddGroupResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterAddGroupResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Groups::Commands::AddGroupResponse::DecodableType & data);
};

class MTRGroupsClusterViewGroupResponseCallbackBridge : public MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>
{
public:
    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                    bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRGroupsClusterViewGroupResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterViewGroupResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Groups::Commands::ViewGroupResponse::DecodableType & data);
};

class MTRGroupsClusterGetGroupMembershipResponseCallbackBridge
    : public MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>
{
public:
    MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRGroupsClusterGetGroupMembershipResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterGetGroupMembershipResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Groups::Commands::GetGroupMembershipResponse::DecodableType & data);
};

class MTRGroupsClusterRemoveGroupResponseCallbackBridge : public MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>
{
public:
    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRGroupsClusterRemoveGroupResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupsClusterRemoveGroupResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Groups::Commands::RemoveGroupResponse::DecodableType & data);
};

class MTRScenesClusterAddSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>
{
public:
    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                   bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                   ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                     keepAlive){};

    MTRScenesClusterAddSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterAddSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::AddSceneResponse::DecodableType & data);
};

class MTRScenesClusterViewSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>
{
public:
    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                    bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRScenesClusterViewSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterViewSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::ViewSceneResponse::DecodableType & data);
};

class MTRScenesClusterRemoveSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>
{
public:
    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRScenesClusterRemoveSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterRemoveSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::RemoveSceneResponse::DecodableType & data);
};

class MTRScenesClusterRemoveAllScenesResponseCallbackBridge
    : public MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>
{
public:
    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRScenesClusterRemoveAllScenesResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterRemoveAllScenesResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Scenes::Commands::RemoveAllScenesResponse::DecodableType & data);
};

class MTRScenesClusterStoreSceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>
{
public:
    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                     bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                     ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRScenesClusterStoreSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterStoreSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::StoreSceneResponse::DecodableType & data);
};

class MTRScenesClusterGetSceneMembershipResponseCallbackBridge
    : public MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>
{
public:
    MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRScenesClusterGetSceneMembershipResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterGetSceneMembershipResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Scenes::Commands::GetSceneMembershipResponse::DecodableType & data);
};

class MTRScenesClusterEnhancedAddSceneResponseCallbackBridge
    : public MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>
{
public:
    MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRScenesClusterEnhancedAddSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterEnhancedAddSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Scenes::Commands::EnhancedAddSceneResponse::DecodableType & data);
};

class MTRScenesClusterEnhancedViewSceneResponseCallbackBridge
    : public MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>
{
public:
    MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRScenesClusterEnhancedViewSceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterEnhancedViewSceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Scenes::Commands::EnhancedViewSceneResponse::DecodableType & data);
};

class MTRScenesClusterCopySceneResponseCallbackBridge : public MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>
{
public:
    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                    bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRScenesClusterCopySceneResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ScenesClusterCopySceneResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::Scenes::Commands::CopySceneResponse::DecodableType & data);
};

class MTROTASoftwareUpdateProviderClusterQueryImageResponseCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderClusterQueryImageResponseCallbackType>
{
public:
    MTROTASoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTROTASoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderClusterQueryImageResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterQueryImageResponseCallbackType>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImageResponse::DecodableType & data);
};

class MTROTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>
{
public:
    MTROTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTROTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterApplyUpdateResponseCallbackType>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateResponse::DecodableType & data);
};

class MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>
{
public:
    MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningClusterArmFailSafeResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterArmFailSafeResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType & data);
};

class MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>
{
public:
    MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningClusterSetRegulatoryConfigResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterSetRegulatoryConfigResponseCallbackType>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfigResponse::DecodableType & data);
};

class MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>
{
public:
    MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningClusterCommissioningCompleteResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterCommissioningCompleteResponseCallbackType>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::GeneralCommissioning::Commands::CommissioningCompleteResponse::DecodableType & data);
};

class MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>
{
public:
    MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterScanNetworksResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterScanNetworksResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworksResponse::DecodableType & data);
};

class MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>
{
public:
    MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterNetworkConfigResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterNetworkConfigResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::NetworkCommissioning::Commands::NetworkConfigResponse::DecodableType & data);
};

class MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>
{
public:
    MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterConnectNetworkResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterConnectNetworkResponseCallbackType>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetworkResponse::DecodableType & data);
};

class MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>
{
public:
    MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsClusterRetrieveLogsResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterRetrieveLogsResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsResponse::DecodableType & data);
};

class MTROperationalCredentialsClusterAttestationResponseCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>
{
public:
    MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterAttestationResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterAttestationResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::OperationalCredentials::Commands::AttestationResponse::DecodableType & data);
};

class MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>
{
public:
    MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterCertificateChainResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterCertificateChainResponseCallbackType>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::OperationalCredentials::Commands::CertificateChainResponse::DecodableType & data);
};

class MTROperationalCredentialsClusterCSRResponseCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>
{
public:
    MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterCSRResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterCSRResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::OperationalCredentials::Commands::CSRResponse::DecodableType & data);
};

class MTROperationalCredentialsClusterNOCResponseCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>
{
public:
    MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterNOCResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterNOCResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::OperationalCredentials::Commands::NOCResponse::DecodableType & data);
};

class MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>
{
public:
    MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementClusterKeySetReadResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadResponse::DecodableType & data);
};

class MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>
{
public:
    MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterKeySetReadAllIndicesResponseCallbackType>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndicesResponse::DecodableType & data);
};

class MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>
{
public:
    MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetWeekDayScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetWeekDayScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::DoorLock::Commands::GetWeekDayScheduleResponse::DecodableType & data);
};

class MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>
{
public:
    MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetYearDayScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetYearDayScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::DoorLock::Commands::GetYearDayScheduleResponse::DecodableType & data);
};

class MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>
{
public:
    MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetHolidayScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetHolidayScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::DoorLock::Commands::GetHolidayScheduleResponse::DecodableType & data);
};

class MTRDoorLockClusterGetUserResponseCallbackBridge : public MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>
{
public:
    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                    bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                    ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRDoorLockClusterGetUserResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetUserResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::Clusters::DoorLock::Commands::GetUserResponse::DecodableType & data);
};

class MTRDoorLockClusterSetCredentialResponseCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>
{
public:
    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockClusterSetCredentialResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterSetCredentialResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::DoorLock::Commands::SetCredentialResponse::DecodableType & data);
};

class MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>
{
public:
    MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRDoorLockClusterGetCredentialStatusResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterGetCredentialStatusResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::DoorLock::Commands::GetCredentialStatusResponse::DecodableType & data);
};

class MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge
    : public MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>
{
public:
    MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRThermostatClusterGetWeeklyScheduleResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterGetWeeklyScheduleResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Thermostat::Commands::GetWeeklyScheduleResponse::DecodableType & data);
};

class MTRChannelClusterChangeChannelResponseCallbackBridge
    : public MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>
{
public:
    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRChannelClusterChangeChannelResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterChangeChannelResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::Channel::Commands::ChangeChannelResponse::DecodableType & data);
};

class MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge
    : public MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>
{
public:
    MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRTargetNavigatorClusterNavigateTargetResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorClusterNavigateTargetResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TargetNavigator::Commands::NavigateTargetResponse::DecodableType & data);
};

class MTRMediaPlaybackClusterPlaybackResponseCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>
{
public:
    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRMediaPlaybackClusterPlaybackResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterPlaybackResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::MediaPlayback::Commands::PlaybackResponse::DecodableType & data);
};

class MTRKeypadInputClusterSendKeyResponseCallbackBridge : public MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>
{
public:
    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRKeypadInputClusterSendKeyResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterSendKeyResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::KeypadInput::Commands::SendKeyResponse::DecodableType & data);
};

class MTRContentLauncherClusterLaunchResponseCallbackBridge
    : public MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>
{
public:
    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRContentLauncherClusterLaunchResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterLaunchResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::ContentLauncher::Commands::LaunchResponse::DecodableType & data);
};

class MTRApplicationLauncherClusterLauncherResponseCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>
{
public:
    MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRApplicationLauncherClusterLauncherResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherClusterLauncherResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::ApplicationLauncher::Commands::LauncherResponse::DecodableType & data);
};

class MTRAccountLoginClusterGetSetupPINResponseCallbackBridge
    : public MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>
{
public:
    MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRAccountLoginClusterGetSetupPINResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccountLoginClusterGetSetupPINResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::AccountLogin::Commands::GetSetupPINResponse::DecodableType & data);
};

class MTRTestClusterClusterTestSpecificResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>
{
public:
    MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestSpecificResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestSpecificResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestSpecificResponse::DecodableType & data);
};

class MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>
{
public:
    MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestAddArgumentsResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestAddArgumentsResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType & data);
};

class MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>
{
public:
    MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestSimpleArgumentResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestSimpleArgumentResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestSimpleArgumentResponse::DecodableType & data);
};

class MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>
{
public:
    MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestStructArrayArgumentResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestStructArrayArgumentResponseCallbackType>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::TestCluster::Commands::TestStructArrayArgumentResponse::DecodableType & data);
};

class MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>
{
public:
    MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestListInt8UReverseResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestListInt8UReverseResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseResponse::DecodableType & data);
};

class MTRTestClusterClusterTestEnumsResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>
{
public:
    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRTestClusterClusterTestEnumsResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEnumsResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestEnumsResponse::DecodableType & data);
};

class MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>
{
public:
    MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestNullableOptionalResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestNullableOptionalResponse::DecodableType & data);
};

class MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>
{
public:
    MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestComplexNullableOptionalResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestComplexNullableOptionalResponseCallbackType>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::TestCluster::Commands::TestComplexNullableOptionalResponse::DecodableType & data);
};

class MTRTestClusterClusterBooleanResponseCallbackBridge : public MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>
{
public:
    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                       bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRTestClusterClusterBooleanResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterBooleanResponseCallbackType>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType & data);
};

class MTRTestClusterClusterSimpleStructResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>
{
public:
    MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterSimpleStructResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & data);
};

class MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>
{
public:
    MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestEmitTestEventResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEmitTestEventResponseCallbackType>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::Clusters::TestCluster::Commands::TestEmitTestEventResponse::DecodableType & data);
};

class MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>
{
public:
    MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterTestEmitTestFabricScopedEventResponseCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterTestEmitTestFabricScopedEventResponseCallbackType>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::Clusters::TestCluster::Commands::TestEmitTestFabricScopedEventResponse::DecodableType & data);
};

class MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge
    : public MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>
{
public:
    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyEffectIdentifier value);
};

class MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge
    : public MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge
{
public:
    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge
    : public MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>
{
public:
    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectIdentifierAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyEffectIdentifier> & value);
};

class MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge
    : public MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge
{
public:
    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIdentifyClusterIdentifyEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge
    : public MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>
{
public:
    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyEffectVariant value);
};

class MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge
    : public MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge
{
public:
    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge
    : public MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>
{
public:
    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyEffectVariantAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyEffectVariant> & value);
};

class MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge
    : public MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge
{
public:
    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIdentifyClusterIdentifyEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge
    : public MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>
{
public:
    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<IdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Identify::IdentifyIdentifyType value);
};

class MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge
    : public MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge
{
public:
    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>
{
public:
    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableIdentifyClusterIdentifyIdentifyTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Identify::IdentifyIdentifyType> & value);
};

class MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge
{
public:
    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIdentifyClusterIdentifyIdentifyTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>
{
public:
    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant value);
};

class MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge
    : public MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge
{
public:
    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>
{
public:
    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffDelayedAllOffEffectVariant> & value);
};

class MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge
    : public MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge
{
public:
    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffDelayedAllOffEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>
{
public:
    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant value);
};

class MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge
    : public MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge
{
public:
    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>
{
public:
    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffDyingLightEffectVariant> & value);
};

class MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge
    : public MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge
{
public:
    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffDyingLightEffectVariantAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>
{
public:
    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffEffectIdentifier value);
};

class MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge
    : public MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
{
public:
    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>
{
public:
    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffEffectIdentifierAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffEffectIdentifier> & value);
};

class MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge
    : public MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge
{
public:
    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffEffectIdentifierAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
    : public MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>
{
public:
    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OnOff::OnOffStartUpOnOff value);
};

class MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge
    : public MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
{
public:
    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>
{
public:
    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableOnOffClusterOnOffStartUpOnOffAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::OnOff::OnOffStartUpOnOff> & value);
};

class MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge
    : public MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge
{
public:
    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOnOffClusterOnOffStartUpOnOffAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLevelControlClusterMoveModeAttributeCallbackBridge : public MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>
{
public:
    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlClusterMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::LevelControl::MoveMode value);
};

class MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge
    : public MTRLevelControlClusterMoveModeAttributeCallbackBridge
{
public:
    MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlClusterMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlClusterMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>
{
public:
    MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableLevelControlClusterMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::LevelControl::MoveMode> & value);
};

class MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge
    : public MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge
{
public:
    MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableLevelControlClusterMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableLevelControlClusterMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRLevelControlClusterStepModeAttributeCallbackBridge : public MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>
{
public:
    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<LevelControlClusterStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::LevelControl::StepMode value);
};

class MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge
    : public MTRLevelControlClusterStepModeAttributeCallbackBridge
{
public:
    MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlClusterStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRLevelControlClusterStepModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableLevelControlClusterStepModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>
{
public:
    MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableLevelControlClusterStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::LevelControl::StepMode> & value);
};

class MTRNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge
    : public MTRNullableLevelControlClusterStepModeAttributeCallbackBridge
{
public:
    MTRNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableLevelControlClusterStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableLevelControlClusterStepModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlClusterAuthModeAttributeCallbackBridge
    : public MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>
{
public:
    MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterAuthModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::AuthMode value);
};

class MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge
    : public MTRAccessControlClusterAuthModeAttributeCallbackBridge
{
public:
    MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlClusterAuthModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlClusterAuthModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>
{
public:
    MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterAuthModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::AuthMode> & value);
};

class MTRNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge
    : public MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge
{
public:
    MTRNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableAccessControlClusterAuthModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAccessControlClusterAuthModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>
{
public:
    MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterChangeTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::ChangeTypeEnum value);
};

class MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge
{
public:
    MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>
{
public:
    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterChangeTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::ChangeTypeEnum> & value);
};

class MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAccessControlClusterChangeTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAccessControlClusterPrivilegeAttributeCallbackBridge
    : public MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>
{
public:
    MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AccessControlClusterPrivilegeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::AccessControl::Privilege value);
};

class MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge
    : public MTRAccessControlClusterPrivilegeAttributeCallbackBridge
{
public:
    MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlClusterPrivilegeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAccessControlClusterPrivilegeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>
{
public:
    MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableAccessControlClusterPrivilegeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::AccessControl::Privilege> & value);
};

class MTRNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge
    : public MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge
{
public:
    MTRNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableAccessControlClusterPrivilegeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAccessControlClusterPrivilegeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsClusterActionErrorEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>
{
public:
    MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionErrorEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Actions::ActionErrorEnum value);
};

class MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge
    : public MTRActionsClusterActionErrorEnumAttributeCallbackBridge
{
public:
    MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterActionErrorEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterActionErrorEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>
{
public:
    MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionErrorEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionErrorEnum> & value);
};

class MTRNullableActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge
{
public:
    MTRNullableActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableActionsClusterActionErrorEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterActionErrorEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsClusterActionStateEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>
{
public:
    MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionStateEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Actions::ActionStateEnum value);
};

class MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge
    : public MTRActionsClusterActionStateEnumAttributeCallbackBridge
{
public:
    MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterActionStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterActionStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>
{
public:
    MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionStateEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionStateEnum> & value);
};

class MTRNullableActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge
{
public:
    MTRNullableActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableActionsClusterActionStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterActionStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsClusterActionTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>
{
public:
    MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterActionTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Actions::ActionTypeEnum value);
};

class MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRActionsClusterActionTypeEnumAttributeCallbackBridge
{
public:
    MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterActionTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterActionTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>
{
public:
    MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterActionTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::ActionTypeEnum> & value);
};

class MTRNullableActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableActionsClusterActionTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterActionTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>
{
public:
    MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<ActionsClusterEndpointListTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Actions::EndpointListTypeEnum value);
};

class MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge
{
public:
    MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>
{
public:
    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullableActionsClusterEndpointListTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Actions::EndpointListTypeEnum> & value);
};

class MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableActionsClusterEndpointListTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>
{
public:
    MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction value);
};

class MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>
{
public:
    MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
                                                                                           MTRLocalActionBlock action,
                                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTAApplyUpdateAction> & value);
};

class MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge
    : public MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge
{
public:
    MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                               action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateProviderClusterOTAApplyUpdateActionAttributeCallbackBridge(queue, device, handler, action,
                                                                                               true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>
{
public:
    MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol value);
};

class MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>
{
public:
    MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
                                                                                          MTRLocalActionBlock action,
                                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol> & value);
};

class MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge
    : public MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge
{
public:
    MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                              action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateProviderClusterOTADownloadProtocolAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>
{
public:
    MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus value);
};

class MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>
{
public:
    MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                     ResponseHandler handler,
                                                                                     MTRLocalActionBlock action,
                                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                     MTRDeviceController * controller,
                                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallback>(queue, device, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateProvider::OTAQueryStatus> & value);
};

class MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge
{
public:
    MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                         true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateProviderClusterOTAQueryStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                     ResponseHandler handler,
                                                                                     MTRLocalActionBlock action,
                                                                                     bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(queue, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                     MTRDeviceController * controller,
                                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                                     bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(queue, device, handler, action,
                                                                                                   OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason value);
};

class MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                         true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>
{
public:
    MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                             ResponseHandler handler,
                                                                                             MTRLocalActionBlock action,
                                                                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
            queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAAnnouncementReason> & value);
};

class MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge
    : public MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge
{
public:
    MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                                 action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateRequestorClusterOTAAnnouncementReasonAttributeCallbackBridge(queue, device, handler, action,
                                                                                                 true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum value);
};

class MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>
{
public:
    MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
                                                                                           MTRLocalActionBlock action,
                                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAChangeReasonEnum> & value);
};

class MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge
{
public:
    MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                               action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateRequestorClusterOTAChangeReasonEnumAttributeCallbackBridge(queue, device, handler, action,
                                                                                               true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge
    : public MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>
{
public:
    MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<OTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum value);
};

class MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge
    : public MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge
{
public:
    MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>
{
public:
    MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
                                                                                          MTRLocalActionBlock action,
                                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum> & value);
};

class MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge
{
public:
    MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                              action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOTASoftwareUpdateRequestorClusterOTAUpdateStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge
    : public MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>
{
public:
    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::TimeFormatLocalization::CalendarType value);
};

class MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge
    : public MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge
{
public:
    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>
{
public:
    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeFormatLocalizationClusterCalendarTypeAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::TimeFormatLocalization::CalendarType> & value);
};

class MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge
{
public:
    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeFormatLocalizationClusterCalendarTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge
    : public MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>
{
public:
    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<TimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::TimeFormatLocalization::HourFormat value);
};

class MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge
    : public MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge
{
public:
    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge
    : public MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>
{
public:
    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeFormatLocalizationClusterHourFormatAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::TimeFormatLocalization::HourFormat> & value);
};

class MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge
    : public MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge
{
public:
    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeFormatLocalizationClusterHourFormatAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge
    : public MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>
{
public:
    MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<UnitLocalizationClusterTempUnitAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::UnitLocalization::TempUnit value);
};

class MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge
    : public MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge
{
public:
    MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge
    : public MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>
{
public:
    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableUnitLocalizationClusterTempUnitAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::UnitLocalization::TempUnit> & value);
};

class MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge
    : public MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge
{
public:
    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableUnitLocalizationClusterTempUnitAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>
{
public:
    MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeFault value);
};

class MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatChargeFault> & value);
};

class MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatChargeFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>
{
public:
    MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeLevelAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeLevel value);
};

class MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeLevelAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatChargeLevel> & value);
};

class MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatChargeLevelAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>
{
public:
    MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatChargeStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatChargeState value);
};

class MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatChargeStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatChargeState> & value);
};

class MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatChargeStateAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterBatFaultAttributeCallbackBridge : public MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>
{
public:
    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRPowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatFault value);
};

class MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge : public MTRPowerSourceClusterBatFaultAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatFault> & value);
};

class MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterBatFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>
{
public:
    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterBatReplaceabilityAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::BatReplaceability value);
};

class MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterBatReplaceabilityAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::BatReplaceability> & value);
};

class MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterBatReplaceabilityAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>
{
public:
    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterPowerSourceStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::PowerSourceStatus value);
};

class MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterPowerSourceStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::PowerSourceStatus> & value);
};

class MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterPowerSourceStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>
{
public:
    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::WiredCurrentType value);
};

class MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterWiredCurrentTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::WiredCurrentType> & value);
};

class MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterWiredCurrentTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPowerSourceClusterWiredFaultAttributeCallbackBridge
    : public MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>
{
public:
    MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<PowerSourceClusterWiredFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PowerSource::WiredFault value);
};

class MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge
    : public MTRPowerSourceClusterWiredFaultAttributeCallbackBridge
{
public:
    MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPowerSourceClusterWiredFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>
{
public:
    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullablePowerSourceClusterWiredFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::PowerSource::WiredFault> & value);
};

class MTRNullablePowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge
    : public MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge
{
public:
    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePowerSourceClusterWiredFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePowerSourceClusterWiredFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>
{
public:
    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralCommissioning::CommissioningError value);
};

class MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge
    : public MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge
{
public:
    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>
{
public:
    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                    MTRLocalActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                    MTRDeviceController * controller,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralCommissioningClusterCommissioningErrorAttributeCallback>(queue, device, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralCommissioning::CommissioningError> & value);
};

class MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge
{
public:
    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                        true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralCommissioningClusterCommissioningErrorAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>
{
public:
    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<GeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType value);
};

class MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge
    : public MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge
{
public:
    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>
{
public:
    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                        ResponseHandler handler,
                                                                                        MTRLocalActionBlock action,
                                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(queue, handler, action,
                                                                                                      OnSuccessFn, keepAlive){};

    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                        MTRDeviceController * controller,
                                                                                        ResponseHandler handler,
                                                                                        MTRActionBlock action,
                                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType> & value);
};

class MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge
{
public:
    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                            action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralCommissioningClusterRegulatoryLocationTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>
{
public:
    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                    MTRLocalActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                    MTRDeviceController * controller,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, device, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus value);
};

class MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge
    : public MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge
{
public:
    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                        true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>
{
public:
    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                            ResponseHandler handler,
                                                                                            MTRLocalActionBlock action,
                                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(queue, handler, action,
                                                                                                          OnSuccessFn, keepAlive){};

    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus> & value);
};

class MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge
{
public:
    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                                action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableNetworkCommissioningClusterNetworkCommissioningStatusAttributeCallbackBridge(queue, device, handler, action,
                                                                                                true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge
    : public MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>
{
public:
    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NetworkCommissioningClusterWiFiBandAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::NetworkCommissioning::WiFiBand value);
};

class MTRNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge
    : public MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge
{
public:
    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge
    : public MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>
{
public:
    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableNetworkCommissioningClusterWiFiBandAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::NetworkCommissioning::WiFiBand> & value);
};

class MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge
    : public MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge
{
public:
    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableNetworkCommissioningClusterWiFiBandAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>
{
public:
    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsIntentAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsIntent value);
};

class MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge
    : public MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
{
public:
    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>
{
public:
    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsIntentAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DiagnosticLogs::LogsIntent> & value);
};

class MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge
    : public MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge
{
public:
    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDiagnosticLogsClusterLogsIntentAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>
{
public:
    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsStatus value);
};

class MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge
    : public MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
{
public:
    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>
{
public:
    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DiagnosticLogs::LogsStatus> & value);
};

class MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge
{
public:
    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDiagnosticLogsClusterLogsStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge
    : public MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>
{
public:
    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<DiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol value);
};

class MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge
    : public MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge
{
public:
    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>
{
public:
    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::DiagnosticLogs::LogsTransferProtocol> & value);
};

class MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge
    : public MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge
{
public:
    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDiagnosticLogsClusterLogsTransferProtocolAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>
{
public:
    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::BootReasonType value);
};

class MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>
{
public:
    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::BootReasonType> & value);
};

class MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge
{
public:
    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterBootReasonTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>
{
public:
    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::HardwareFaultType value);
};

class MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>
{
public:
    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::HardwareFaultType> & value);
};

class MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge
{
public:
    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterHardwareFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>
{
public:
    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::InterfaceType value);
};

class MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>
{
public:
    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::InterfaceType> & value);
};

class MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge
{
public:
    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterInterfaceTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>
{
public:
    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::NetworkFaultType value);
};

class MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>
{
public:
    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::NetworkFaultType> & value);
};

class MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge
{
public:
    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterNetworkFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>
{
public:
    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<GeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GeneralDiagnostics::RadioFaultType value);
};

class MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge
{
public:
    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>
{
public:
    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::GeneralDiagnostics::RadioFaultType> & value);
};

class MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge
{
public:
    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGeneralDiagnosticsClusterRadioFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault value);
};

class MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>
{
public:
    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::NetworkFault> & value);
};

class MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge
    : public MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge
{
public:
    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThreadNetworkDiagnosticsClusterNetworkFaultAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole value);
};

class MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>
{
public:
    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole> & value);
};

class MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge
    : public MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge
{
public:
    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThreadNetworkDiagnosticsClusterRoutingRoleAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge
    : public MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>
{
public:
    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                    MTRLocalActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                    MTRDeviceController * controller,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, device, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus value);
};

class MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge
    : public MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge
{
public:
    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                        true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>
{
public:
    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                            ResponseHandler handler,
                                                                                            MTRLocalActionBlock action,
                                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(queue, handler, action,
                                                                                                          OnSuccessFn, keepAlive){};

    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::ThreadNetworkDiagnostics::ThreadConnectionStatus> & value);
};

class MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge
{
public:
    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                                action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThreadNetworkDiagnosticsClusterThreadConnectionStatusAttributeCallbackBridge(queue, device, handler, action,
                                                                                                true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause value);
};

class MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge
    : public MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                           ResponseHandler handler,
                                                                                           MTRLocalActionBlock action,
                                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(queue, handler, action,
                                                                                                         OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::AssociationFailureCause> & value);
};

class MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge
    : public MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                               action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterAssociationFailureCauseAttributeCallbackBridge(queue, device, handler, action,
                                                                                               true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType value);
};

class MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::SecurityType> & value);
};

class MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterSecurityTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus value);
};

class MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                        ResponseHandler handler,
                                                                                        MTRLocalActionBlock action,
                                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(queue, handler, action,
                                                                                                      OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                        MTRDeviceController * controller,
                                                                                        ResponseHandler handler,
                                                                                        MTRActionBlock action,
                                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiConnectionStatus> & value);
};

class MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                            action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterWiFiConnectionStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge
    : public MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>
{
public:
    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<WiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType value);
};

class MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge
    : public MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge
{
public:
    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionType> & value);
};

class MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge
{
public:
    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWiFiNetworkDiagnosticsClusterWiFiVersionTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge
    : public MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>
{
public:
    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<EthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType value);
};

class MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge
    : public MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge
{
public:
    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTREthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>
{
public:
    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateType> & value);
};

class MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge
{
public:
    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableEthernetNetworkDiagnosticsClusterPHYRateTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge
    : public MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>
{
public:
    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<TimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::TimeSynchronization::GranularityEnum value);
};

class MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge
    : public MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge
{
public:
    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>
{
public:
    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeSynchronizationClusterGranularityEnumAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::GranularityEnum> & value);
};

class MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge
{
public:
    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeSynchronizationClusterGranularityEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge
    : public MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>
{
public:
    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<TimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value);
};

class MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge
    : public MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge
{
public:
    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>
{
public:
    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                             keepAlive){};

    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                               MTRDeviceController * controller,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                             action, OnSuccessFn, keepAlive){};

    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                               ResponseHandler handler, MTRActionBlock action,
                                                                               bool keepAlive = false) :
        MTRCallbackBridge<NullableTimeSynchronizationClusterTimeSourceEnumAttributeCallback>(queue, device, handler, action,
                                                                                             OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::TimeSynchronization::TimeSourceEnum> & value);
};

class MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge
{
public:
    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                   true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTimeSynchronizationClusterTimeSourceEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge
    : public MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>
{
public:
    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
                                                                                         MTRLocalActionBlock action,
                                                                                         bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(queue, handler, action,
                                                                                                       OnSuccessFn, keepAlive){};

    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus value);
};

class MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge
    : public MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge
{
public:
    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                             action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>
{
public:
    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                                 ResponseHandler handler,
                                                                                                 MTRLocalActionBlock action,
                                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
            queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatus> & value);
};

class MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge
{
public:
    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, nodeID, controller,
                                                                                                     handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAdministratorCommissioningClusterCommissioningWindowStatusAttributeCallbackBridge(queue, device, handler, action,
                                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge
    : public MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>
{
public:
    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<AdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::AdministratorCommissioning::StatusCode value);
};

class MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge
    : public MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge
{
public:
    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>
{
public:
    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableAdministratorCommissioningClusterStatusCodeAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::AdministratorCommissioning::StatusCode> & value);
};

class MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge
    : public MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge
{
public:
    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAdministratorCommissioningClusterStatusCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge
    : public MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>
{
public:
    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<OperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::OperationalCredentials::OperationalCertStatus value);
};

class MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge
    : public MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge
{
public:
    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTROperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>
{
public:
    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                         ResponseHandler handler,
                                                                                         MTRLocalActionBlock action,
                                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(queue, handler, action,
                                                                                                       OnSuccessFn, keepAlive){};

    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableOperationalCredentialsClusterOperationalCertStatusAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::OperationalCredentials::OperationalCertStatus> & value);
};

class MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge
{
public:
    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                             action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableOperationalCredentialsClusterOperationalCertStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge
    : public MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>
{
public:
    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<GroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy value);
};

class MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge
    : public MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge
{
public:
    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge
    : public MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>
{
public:
    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler,
                                                                                      MTRLocalActionBlock action,
                                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                      MTRDeviceController * controller,
                                                                                      ResponseHandler handler,
                                                                                      MTRActionBlock action,
                                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallback>(queue, device, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::GroupKeyManagement::GroupKeySecurityPolicy> & value);
};

class MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge
    : public MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge
{
public:
    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                          action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableGroupKeyManagementClusterGroupKeySecurityPolicyAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>
{
public:
    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlAlarmCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlAlarmCode value);
};

class MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlAlarmCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlAlarmCode> & value);
};

class MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlAlarmCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>
{
public:
    MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlCredentialRuleAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlCredentialRule value);
};

class MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlCredentialRuleAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlCredentialRule> & value);
};

class MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlCredentialRuleAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlCredentialTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlCredentialType value);
};

class MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlCredentialTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlCredentialType> & value);
};

class MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlCredentialTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlDataOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDataOperationType value);
};

class MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlDataOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlDataOperationType> & value);
};

class MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlDataOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlDoorStateAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>
{
public:
    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlDoorStateAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlDoorState value);
};

class MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlDoorStateAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlDoorStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlDoorState> & value);
};

class MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlDoorStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlDoorStateAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                            MTRDeviceController * controller, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                          keepAlive){};

    MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                            MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockDataTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockDataType value);
};

class MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockDataTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockDataType> & value);
};

class MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockDataTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockOperationType value);
};

class MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockOperationTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockOperationType> & value);
};

class MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockOperationTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlLockStateAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>
{
public:
    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                       keepAlive){};

    MTRDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockStateAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockState value);
};

class MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlLockStateAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockStateAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockStateAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockState> & value);
};

class MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlLockStateAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockStateAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlLockTypeAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlLockTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlLockType value);
};

class MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlLockTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlLockTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlLockType> & value);
};

class MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlLockTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlLockTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>
{
public:
    MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperatingModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperatingMode value);
};

class MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperatingModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlOperatingMode> & value);
};

class MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlOperatingModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>
{
public:
    MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperationErrorAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperationError value);
};

class MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperationErrorAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlOperationError> & value);
};

class MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlOperationErrorAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>
{
public:
    MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlOperationSourceAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlOperationSource value);
};

class MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlOperationSourceAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlOperationSource> & value);
};

class MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlOperationSourceAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlStatusAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>
{
public:
    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                      bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller,
                                                      ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                    keepAlive){};

    MTRDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlStatus value);
};

class MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlStatusAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlStatus> & value);
};

class MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlUserStatusAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>
{
public:
    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                        keepAlive){};

    MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlUserStatus value);
};

class MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDlUserStatusAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlUserStatus> & value);
};

class MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlUserStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDlUserTypeAttributeCallbackBridge : public MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDlUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DlUserType value);
};

class MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge : public MTRDoorLockClusterDlUserTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDlUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DlUserType> & value);
};

class MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDlUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDlUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>
{
public:
    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockOperationEventCode value);
};

class MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockOperationEventCodeAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockOperationEventCode> & value);
};

class MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockOperationEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>
{
public:
    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode value);
};

class MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockProgrammingEventCode> & value);
};

class MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockProgrammingEventCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>
{
public:
    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus value);
};

class MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockSetPinOrIdStatus> & value);
};

class MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockSetPinOrIdStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>
{
public:
    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockUserStatus value);
};

class MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                        MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                      OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                        ResponseHandler handler, MTRActionBlock action,
                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserStatusAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                      keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockUserStatus> & value);
};

class MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockUserStatusAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
    : public MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>
{
public:
    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<DoorLockClusterDoorLockUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::DoorLock::DoorLockUserType value);
};

class MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge
    : public MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
{
public:
    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>
{
public:
    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableDoorLockClusterDoorLockUserTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::DoorLockUserType> & value);
};

class MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge
{
public:
    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableDoorLockClusterDoorLockUserTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge
    : public MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>
{
public:
    MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringClusterEndProductTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::WindowCovering::EndProductType value);
};

class MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge
    : public MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge
{
public:
    MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>
{
public:
    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableWindowCoveringClusterEndProductTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::WindowCovering::EndProductType> & value);
};

class MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge
{
public:
    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWindowCoveringClusterEndProductTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRWindowCoveringClusterTypeAttributeCallbackBridge : public MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>
{
public:
    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, MTRLocalActionBlock action,
                                                        bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                        MTRDeviceController * controller, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                      keepAlive){};

    MTRWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<WindowCoveringClusterTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::WindowCovering::Type value);
};

class MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge : public MTRWindowCoveringClusterTypeAttributeCallbackBridge
{
public:
    MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRWindowCoveringClusterTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>
{
public:
    MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                MTRDeviceController * controller, ResponseHandler handler,
                                                                MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                              OnSuccessFn, keepAlive){};

    MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                ResponseHandler handler, MTRActionBlock action,
                                                                bool keepAlive = false) :
        MTRCallbackBridge<NullableWindowCoveringClusterTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                              keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::WindowCovering::Type> & value);
};

class MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge
{
public:
    MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableWindowCoveringClusterTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableWindowCoveringClusterTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge
    : public MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>
{
public:
    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                MTRLocalActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                              keepAlive){};

    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                MTRDeviceController * controller,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                              action, OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                ResponseHandler handler, MTRActionBlock action,
                                                                                bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, device, handler, action,
                                                                                              OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode value);
};

class MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge
    : public MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge
{
public:
    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                    true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>
{
public:
    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                        ResponseHandler handler,
                                                                                        MTRLocalActionBlock action,
                                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(queue, handler, action,
                                                                                                      OnSuccessFn, keepAlive){};

    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                        MTRDeviceController * controller,
                                                                                        ResponseHandler handler,
                                                                                        MTRActionBlock action,
                                                                                        bool keepAlive = false) :
        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::PumpConfigurationAndControl::PumpControlMode> & value);
};

class MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge
    : public MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge
{
public:
    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                            action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePumpConfigurationAndControlClusterPumpControlModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge
    : public MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>
{
public:
    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<PumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode value);
};

class MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge
    : public MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge
{
public:
    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRPumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>
{
public:
    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                          ResponseHandler handler,
                                                                                          MTRLocalActionBlock action,
                                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(queue, handler, action,
                                                                                                        OnSuccessFn, keepAlive){};

    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::PumpConfigurationAndControl::PumpOperationMode> & value);
};

class MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge
    : public MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge
{
public:
    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                              action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullablePumpConfigurationAndControlClusterPumpOperationModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>
{
public:
    MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterSetpointAdjustModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::SetpointAdjustMode value);
};

class MTRThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge
    : public MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge
{
public:
    MTRThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>
{
public:
    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterSetpointAdjustModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::SetpointAdjustMode> & value);
};

class MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge
    : public MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge
{
public:
    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterSetpointAdjustModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>
{
public:
    MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatControlSequenceAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::ThermostatControlSequence value);
};

class MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge
    : public MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge
{
public:
    MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>
{
public:
    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                 MTRLocalActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                               keepAlive){};

    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                 MTRDeviceController * controller,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, nodeID, controller, handler,
                                                                                               action, OnSuccessFn, keepAlive){};

    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                                 bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatControlSequenceAttributeCallback>(queue, device, handler, action,
                                                                                               OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatControlSequence> & value);
};

class MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge
    : public MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge
{
public:
    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                     true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterThermostatControlSequenceAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>
{
public:
    MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatRunningModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::ThermostatRunningMode value);
};

class MTRThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge
    : public MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge
{
public:
    MTRThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>
{
public:
    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                           keepAlive){};

    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                           action, OnSuccessFn, keepAlive){};

    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatRunningModeAttributeCallback>(queue, device, handler, action,
                                                                                           OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatRunningMode> & value);
};

class MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge
    : public MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge
{
public:
    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterThermostatRunningModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge
    : public MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>
{
public:
    MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ThermostatClusterThermostatSystemModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Thermostat::ThermostatSystemMode value);
};

class MTRThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge
    : public MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge
{
public:
    MTRThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>
{
public:
    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableThermostatClusterThermostatSystemModeAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Thermostat::ThermostatSystemMode> & value);
};

class MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge
    : public MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge
{
public:
    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableThermostatClusterThermostatSystemModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge
    : public MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>
{
public:
    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<FanControlClusterFanModeSequenceTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::FanControl::FanModeSequenceType value);
};

class MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge
    : public MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge
{
public:
    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>
{
public:
    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableFanControlClusterFanModeSequenceTypeAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::FanControl::FanModeSequenceType> & value);
};

class MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge
{
public:
    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFanControlClusterFanModeSequenceTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFanControlClusterFanModeTypeAttributeCallbackBridge
    : public MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>
{
public:
    MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FanControlClusterFanModeTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::FanControl::FanModeType value);
};

class MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge
    : public MTRFanControlClusterFanModeTypeAttributeCallbackBridge
{
public:
    MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFanControlClusterFanModeTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>
{
public:
    MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableFanControlClusterFanModeTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::FanControl::FanModeType> & value);
};

class MTRNullableFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge
{
public:
    MTRNullableFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableFanControlClusterFanModeTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFanControlClusterFanModeTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterColorLoopActionAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>
{
public:
    MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                 MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                 MTRDeviceController * controller, ResponseHandler handler,
                                                                 MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                               OnSuccessFn, keepAlive){};

    MTRColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                 ResponseHandler handler, MTRActionBlock action,
                                                                 bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorLoopActionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                               keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorLoopAction value);
};

class MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterColorLoopActionAttributeCallbackBridge
{
public:
    MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                             MTRDeviceController * controller,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterColorLoopActionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                             ResponseHandler handler, MTRActionBlock action,
                                                                             MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterColorLoopActionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>
{
public:
    MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                         MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                       OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorLoopActionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                       keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorLoopAction> & value);
};

class MTRNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterColorLoopActionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterColorLoopActionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>
{
public:
    MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorLoopDirectionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorLoopDirection value);
};

class MTRColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge
{
public:
    MTRColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>
{
public:
    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorLoopDirectionAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorLoopDirection> & value);
};

class MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterColorLoopDirectionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterColorModeAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>
{
public:
    MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterColorModeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::ColorMode value);
};

class MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterColorModeAttributeCallbackBridge
{
public:
    MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterColorModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterColorModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterColorModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterColorModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>
{
public:
    MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterColorModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterColorModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::ColorMode> & value);
};

class MTRNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterColorModeAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterColorModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterColorModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterColorModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterHueDirectionAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>
{
public:
    MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueDirectionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueDirection value);
};

class MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterHueDirectionAttributeCallbackBridge
{
public:
    MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterHueDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterHueDirectionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>
{
public:
    MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueDirectionAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::HueDirection> & value);
};

class MTRNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterHueDirectionAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterHueDirectionAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterHueMoveModeAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>
{
public:
    MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueMoveMode value);
};

class MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterHueMoveModeAttributeCallbackBridge
{
public:
    MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterHueMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterHueMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>
{
public:
    MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::HueMoveMode> & value);
};

class MTRNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterHueMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterHueMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterHueStepModeAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>
{
public:
    MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterHueStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::HueStepMode value);
};

class MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterHueStepModeAttributeCallbackBridge
{
public:
    MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterHueStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterHueStepModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>
{
public:
    MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterHueStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::HueStepMode> & value);
};

class MTRNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterHueStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterHueStepModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>
{
public:
    MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterSaturationMoveModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::SaturationMoveMode value);
};

class MTRColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge
{
public:
    MTRColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>
{
public:
    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterSaturationMoveModeAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::SaturationMoveMode> & value);
};

class MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterSaturationMoveModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRColorControlClusterSaturationStepModeAttributeCallbackBridge
    : public MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>
{
public:
    MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<ColorControlClusterSaturationStepModeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ColorControl::SaturationStepMode value);
};

class MTRColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge
    : public MTRColorControlClusterSaturationStepModeAttributeCallbackBridge
{
public:
    MTRColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>
{
public:
    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableColorControlClusterSaturationStepModeAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ColorControl::SaturationStepMode> & value);
};

class MTRNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge
    : public MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge
{
public:
    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableColorControlClusterSaturationStepModeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableColorControlClusterSaturationStepModeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge
    : public MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>
{
public:
    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<IlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::IlluminanceMeasurement::LightSensorType value);
};

class MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge
    : public MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge
{
public:
    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>
{
public:
    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::IlluminanceMeasurement::LightSensorType> & value);
};

class MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge
{
public:
    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableIlluminanceMeasurementClusterLightSensorTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelClusterChannelStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>
{
public:
    MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                              MTRDeviceController * controller, ResponseHandler handler,
                                                              MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                              ResponseHandler handler, MTRActionBlock action,
                                                              bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterChannelStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                            keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Channel::ChannelStatusEnum value);
};

class MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRChannelClusterChannelStatusEnumAttributeCallbackBridge
{
public:
    MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>
{
public:
    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableChannelClusterChannelStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::ChannelStatusEnum> & value);
};

class MTRNullableChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableChannelClusterChannelStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableChannelClusterChannelStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>
{
public:
    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<ChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::Channel::LineupInfoTypeEnum value);
};

class MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
{
public:
    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>
{
public:
    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NullableChannelClusterLineupInfoTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::Channel::LineupInfoTypeEnum> & value);
};

class MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableChannelClusterLineupInfoTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>
{
public:
    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<TargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::TargetNavigator::TargetNavigatorStatusEnum value);
};

class MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge
{
public:
    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>
{
public:
    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler,
                                                                                      MTRLocalActionBlock action,
                                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};

    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                      MTRDeviceController * controller,
                                                                                      ResponseHandler handler,
                                                                                      MTRActionBlock action,
                                                                                      bool keepAlive = false) :
        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::TargetNavigator::TargetNavigatorStatusEnum> & value);
};

class MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                          action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTargetNavigatorClusterTargetNavigatorStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>
{
public:
    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::MediaPlayback::MediaPlaybackStatusEnum value);
};

class MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
{
public:
    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>
{
public:
    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                  MTRLocalActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                                keepAlive){};

    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                  MTRDeviceController * controller,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                action, OnSuccessFn, keepAlive){};

    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                                  bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                                OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::MediaPlaybackStatusEnum> & value);
};

class MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                      true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableMediaPlaybackClusterMediaPlaybackStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge
    : public MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>
{
public:
    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                    MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                    MTRDeviceController * controller, ResponseHandler handler,
                                                                    MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                  OnSuccessFn, keepAlive){};

    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                    bool keepAlive = false) :
        MTRCallbackBridge<MediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                  keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value);
};

class MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge
    : public MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge
{
public:
    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>
{
public:
    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaPlaybackClusterPlaybackStateEnumAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::MediaPlayback::PlaybackStateEnum> & value);
};

class MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge
{
public:
    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableMediaPlaybackClusterPlaybackStateEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>
{
public:
    MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<MediaInputClusterInputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::MediaInput::InputTypeEnum value);
};

class MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge
{
public:
    MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>
{
public:
    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableMediaInputClusterInputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::MediaInput::InputTypeEnum> & value);
};

class MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableMediaInputClusterInputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge
    : public MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>
{
public:
    MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterCecKeyCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::KeypadInput::CecKeyCode value);
};

class MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge
    : public MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge
{
public:
    MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>
{
public:
    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableKeypadInputClusterCecKeyCodeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::KeypadInput::CecKeyCode> & value);
};

class MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge
    : public MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge
{
public:
    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableKeypadInputClusterCecKeyCodeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>
{
public:
    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                      MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                      MTRDeviceController * controller, ResponseHandler handler,
                                                                      MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                    OnSuccessFn, keepAlive){};

    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                      ResponseHandler handler, MTRActionBlock action,
                                                                      bool keepAlive = false) :
        MTRCallbackBridge<KeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                    keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::KeypadInput::KeypadInputStatusEnum value);
};

class MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge
{
public:
    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>
{
public:
    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                              MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                            keepAlive){};

    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                              MTRDeviceController * controller,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                            action, OnSuccessFn, keepAlive){};

    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                              ResponseHandler handler, MTRActionBlock action,
                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableKeypadInputClusterKeypadInputStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                            OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::KeypadInput::KeypadInputStatusEnum> & value);
};

class MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableKeypadInputClusterKeypadInputStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>
{
public:
    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                            MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                          keepAlive){};

    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                            MTRDeviceController * controller,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                          action, OnSuccessFn, keepAlive){};

    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                            ResponseHandler handler, MTRActionBlock action,
                                                                            bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                          OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ContentLaunchStatusEnum value);
};

class MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge
{
public:
    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>
{
public:
    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                    MTRLocalActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                    MTRDeviceController * controller,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                    ResponseHandler handler, MTRActionBlock action,
                                                                                    bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterContentLaunchStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                                  OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::ContentLaunchStatusEnum> & value);
};

class MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                        true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableContentLauncherClusterContentLaunchStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>
{
public:
    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::MetricTypeEnum value);
};

class MTRContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge
{
public:
    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>
{
public:
    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterMetricTypeEnumAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::MetricTypeEnum> & value);
};

class MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableContentLauncherClusterMetricTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRContentLauncherClusterParameterEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>
{
public:
    MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                  MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                  MTRDeviceController * controller, ResponseHandler handler,
                                                                  MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                OnSuccessFn, keepAlive){};

    MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                  ResponseHandler handler, MTRActionBlock action,
                                                                  bool keepAlive = false) :
        MTRCallbackBridge<ContentLauncherClusterParameterEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ContentLauncher::ParameterEnum value);
};

class MTRContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge
    : public MTRContentLauncherClusterParameterEnumAttributeCallbackBridge
{
public:
    MTRContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>
{
public:
    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                          MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                          MTRDeviceController * controller, ResponseHandler handler,
                                                                          MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                        OnSuccessFn, keepAlive){};

    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                          ResponseHandler handler, MTRActionBlock action,
                                                                          bool keepAlive = false) :
        MTRCallbackBridge<NullableContentLauncherClusterParameterEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                        keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::ContentLauncher::ParameterEnum> & value);
};

class MTRNullableContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge
{
public:
    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableContentLauncherClusterParameterEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableContentLauncherClusterParameterEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>
{
public:
    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                               MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                               MTRDeviceController * controller, ResponseHandler handler,
                                                               MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                             OnSuccessFn, keepAlive){};

    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                               ResponseHandler handler, MTRActionBlock action,
                                                               bool keepAlive = false) :
        MTRCallbackBridge<AudioOutputClusterOutputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                             keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::AudioOutput::OutputTypeEnum value);
};

class MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
{
public:
    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>
{
public:
    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                       MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                     OnSuccessFn, keepAlive){};

    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       bool keepAlive = false) :
        MTRCallbackBridge<NullableAudioOutputClusterOutputTypeEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                     keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::AudioOutput::OutputTypeEnum> & value);
};

class MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge
{
public:
    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableAudioOutputClusterOutputTypeEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>
{
public:
    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                      ResponseHandler handler,
                                                                                      MTRLocalActionBlock action,
                                                                                      bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};

    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                      MTRDeviceController * controller,
                                                                                      ResponseHandler handler,
                                                                                      MTRActionBlock action,
                                                                                      bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                                    OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatusEnum value);
};

class MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge
{
public:
    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler,
                                                                                          action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>
{
public:
    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(dispatch_queue_t queue,
                                                                                              ResponseHandler handler,
                                                                                              MTRLocalActionBlock action,
                                                                                              bool keepAlive = false) :
        MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
            queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
            queue, nodeID, controller, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallback>(
            queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(
        void * context,
        const chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationLauncher::ApplicationLauncherStatusEnum> & value);
};

class MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, nodeID, controller,
                                                                                                  handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableApplicationLauncherClusterApplicationLauncherStatusEnumAttributeCallbackBridge(queue, device, handler, action,
                                                                                                  true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>
{
public:
    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                         keepAlive){};

    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                           MTRDeviceController * controller,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                           ResponseHandler handler, MTRActionBlock action,
                                                                           bool keepAlive = false) :
        MTRCallbackBridge<ApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                         OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value);
};

class MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge
{
public:
    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>
{
public:
    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                                   MTRLocalActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                                   MTRDeviceController * controller,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, nodeID, controller, handler,
                                                                                                 action, OnSuccessFn, keepAlive){};

    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableApplicationBasicClusterApplicationStatusEnumAttributeCallback>(queue, device, handler, action,
                                                                                                 OnSuccessFn, keepAlive){};

    static void
    OnSuccessFn(void * context,
                const chip::app::DataModel::Nullable<chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum> & value);
};

class MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge
{
public:
    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action,
                                                                                       true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableApplicationBasicClusterApplicationStatusEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRTestClusterClusterSimpleEnumAttributeCallbackBridge
    : public MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>
{
public:
    MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                           MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                           MTRDeviceController * controller, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                         keepAlive){};

    MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler,
                                                           MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<TestClusterClusterSimpleEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn, keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::TestCluster::SimpleEnum value);
};

class MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge
    : public MTRTestClusterClusterSimpleEnumAttributeCallbackBridge
{
public:
    MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                       MTRDeviceController * controller, ResponseHandler handler,
                                                                       MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                       ResponseHandler handler, MTRActionBlock action,
                                                                       MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge
    : public MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>
{
public:
    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                   MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                   MTRDeviceController * controller, ResponseHandler handler,
                                                                   MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                 OnSuccessFn, keepAlive){};

    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                   ResponseHandler handler, MTRActionBlock action,
                                                                   bool keepAlive = false) :
        MTRCallbackBridge<NullableTestClusterClusterSimpleEnumAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                 keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::SimpleEnum> & value);
};

class MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge
    : public MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge
{
public:
    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableTestClusterClusterSimpleEnumAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableTestClusterClusterSimpleEnumAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>
{
public:
    MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                             MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn, keepAlive){};

    MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                             MTRDeviceController * controller, ResponseHandler handler,
                                                             MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                             ResponseHandler handler, MTRActionBlock action,
                                                             bool keepAlive = false) :
        MTRCallbackBridge<FaultInjectionClusterFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                           keepAlive){};

    static void OnSuccessFn(void * context, chip::app::Clusters::FaultInjection::FaultType value);
};

class MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge
{
public:
    MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                         MTRDeviceController * controller, ResponseHandler handler,
                                                                         MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                         ResponseHandler handler, MTRActionBlock action,
                                                                         MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};

class MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge
    : public MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>
{
public:
    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler,
                                                                     MTRLocalActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, chip::NodeId nodeID,
                                                                     MTRDeviceController * controller, ResponseHandler handler,
                                                                     MTRActionBlock action, bool keepAlive = false) :
        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, nodeID, controller, handler, action,
                                                                                   OnSuccessFn, keepAlive){};

    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(dispatch_queue_t queue, MTRBaseDevice * device,
                                                                     ResponseHandler handler, MTRActionBlock action,
                                                                     bool keepAlive = false) :
        MTRCallbackBridge<NullableFaultInjectionClusterFaultTypeAttributeCallback>(queue, device, handler, action, OnSuccessFn,
                                                                                   keepAlive){};

    static void OnSuccessFn(void * context,
                            const chip::app::DataModel::Nullable<chip::app::Clusters::FaultInjection::FaultType> & value);
};

class MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge
    : public MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge
{
public:
    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, chip::NodeId nodeID, MTRDeviceController * controller, ResponseHandler handler,
        MTRActionBlock action, MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, nodeID, controller, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackSubscriptionBridge(
        dispatch_queue_t queue, MTRBaseDevice * device, ResponseHandler handler, MTRActionBlock action,
        MTRSubscriptionEstablishedHandler establishedHandler) :
        MTRNullableFaultInjectionClusterFaultTypeAttributeCallbackBridge(queue, device, handler, action, true),
        mEstablishedHandler(establishedHandler)
    {}

    static void OnSubscriptionEstablished(void * context);

private:
    MTRSubscriptionEstablishedHandler mEstablishedHandler;
};