Google Git
Sign in
pigweed / third_party / github / project-chip / connectedhomeip / 127cebba9049d438ee34bbcd15213eb4f4550a4e / . / zzz_generated / chip-tool / zap-generated / cluster / Commands.h
blob: 4fbcefa8193e8ef5961c4b9acdb6164b08c4ba0a [file] [log] [blame]
/*
*
* Copyright (c) 2022 Project CHIP Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// THIS FILE IS GENERATED BY ZAP
#pragma once
#include <cstdint>
#include <string>
#include <type_traits>
#include <app-common/zap-generated/cluster-objects.h>
#include <commands/clusters/ClusterCommand.h>
#include <commands/clusters/ComplexArgument.h>
#include <commands/clusters/ReportCommand.h>
#include <commands/clusters/WriteAttributeCommand.h>
/*----------------------------------------------------------------------------*\
| Cluster Name | ID |
|---------------------------------------------------------------------+--------|
| AccessControl | 0x001F |
| AccountLogin | 0x050E |
| AdministratorCommissioning | 0x003C |
| ApplicationBasic | 0x050D |
| ApplicationLauncher | 0x050C |
| AudioOutput | 0x050B |
| BarrierControl | 0x0103 |
| Basic | 0x0028 |
| BinaryInputBasic | 0x000F |
| Binding | 0x001E |
| BooleanState | 0x0045 |
| BridgedActions | 0x0025 |
| BridgedDeviceBasic | 0x0039 |
| Channel | 0x0504 |
| ColorControl | 0x0300 |
| ContentLauncher | 0x050A |
| Descriptor | 0x001D |
| DiagnosticLogs | 0x0032 |
| DoorLock | 0x0101 |
| ElectricalMeasurement | 0x0B04 |
| EthernetNetworkDiagnostics | 0x0037 |
| FixedLabel | 0x0040 |
| FlowMeasurement | 0x0404 |
| GeneralCommissioning | 0x0030 |
| GeneralDiagnostics | 0x0033 |
| GroupKeyManagement | 0x003F |
| Groups | 0x0004 |
| Identify | 0x0003 |
| IlluminanceMeasurement | 0x0400 |
| KeypadInput | 0x0509 |
| LevelControl | 0x0008 |
| LocalizationConfiguration | 0x002B |
| LowPower | 0x0508 |
| MediaInput | 0x0507 |
| MediaPlayback | 0x0506 |
| ModeSelect | 0x0050 |
| NetworkCommissioning | 0x0031 |
| OtaSoftwareUpdateProvider | 0x0029 |
| OtaSoftwareUpdateRequestor | 0x002A |
| OccupancySensing | 0x0406 |
| OnOff | 0x0006 |
| OnOffSwitchConfiguration | 0x0007 |
| OperationalCredentials | 0x003E |
| PowerSource | 0x002F |
| PowerSourceConfiguration | 0x002E |
| PressureMeasurement | 0x0403 |
| PumpConfigurationAndControl | 0x0200 |
| RelativeHumidityMeasurement | 0x0405 |
| Scenes | 0x0005 |
| SoftwareDiagnostics | 0x0034 |
| Switch | 0x003B |
| TargetNavigator | 0x0505 |
| TemperatureMeasurement | 0x0402 |
| TestCluster | 0x050F |
| Thermostat | 0x0201 |
| ThermostatUserInterfaceConfiguration | 0x0204 |
| ThreadNetworkDiagnostics | 0x0035 |
| TimeFormatLocalization | 0x002C |
| UnitLocalization | 0x002D |
| UserLabel | 0x0041 |
| WakeOnLan | 0x0503 |
| WiFiNetworkDiagnostics | 0x0036 |
| WindowCovering | 0x0102 |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster AccessControl | 0x001F |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Acl | 0x0000 |
| * Extension | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * AccessControlEntryChanged | 0x0000 |
| * AccessControlExtensionChanged | 0x0001 |
\*----------------------------------------------------------------------------*/
class WriteAccessControlAcl : public WriteAttribute
{
public:
WriteAccessControlAcl(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("Acl", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "acl");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteAccessControlAcl() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000001F, 0x00000000, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type> mValue;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::AccessControlEntry::Type>>
mComplex;
};
class WriteAccessControlExtension : public WriteAttribute
{
public:
WriteAccessControlExtension(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("Extension", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "extension");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteAccessControlExtension() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000001F, 0x00000001, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type> mValue;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::AccessControl::Structs::ExtensionEntry::Type>>
mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster AccountLogin | 0x050E |
|------------------------------------------------------------------------------|
| Commands: | |
| * GetSetupPINRequest | 0x00 |
| * LoginRequest | 0x02 |
| * LogoutRequest | 0x03 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command GetSetupPINRequest
*/
class AccountLoginGetSetupPINRequest : public ClusterCommand
{
public:
AccountLoginGetSetupPINRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-setup-pinrequest", credsIssuerConfig)
{
AddArgument("TempAccountIdentifier", &mRequest.tempAccountIdentifier);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050E) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050E, 0x00000000, mRequest);
}
private:
chip::app::Clusters::AccountLogin::Commands::GetSetupPINRequest::Type mRequest;
};
/*
* Command LoginRequest
*/
class AccountLoginLoginRequest : public ClusterCommand
{
public:
AccountLoginLoginRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("login-request", credsIssuerConfig)
{
AddArgument("TempAccountIdentifier", &mRequest.tempAccountIdentifier);
AddArgument("SetupPIN", &mRequest.setupPIN);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050E) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050E, 0x00000002, mRequest);
}
private:
chip::app::Clusters::AccountLogin::Commands::LoginRequest::Type mRequest;
};
/*
* Command LogoutRequest
*/
class AccountLoginLogoutRequest : public ClusterCommand
{
public:
AccountLoginLogoutRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("logout-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050E) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050E, 0x00000003, mRequest);
}
private:
chip::app::Clusters::AccountLogin::Commands::LogoutRequest::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster AdministratorCommissioning | 0x003C |
|------------------------------------------------------------------------------|
| Commands: | |
| * OpenBasicCommissioningWindow | 0x01 |
| * OpenCommissioningWindow | 0x00 |
| * RevokeCommissioning | 0x02 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * WindowStatus | 0x0000 |
| * AdminFabricIndex | 0x0001 |
| * AdminVendorId | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command OpenBasicCommissioningWindow
*/
class AdministratorCommissioningOpenBasicCommissioningWindow : public ClusterCommand
{
public:
AdministratorCommissioningOpenBasicCommissioningWindow(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("open-basic-commissioning-window", credsIssuerConfig)
{
AddArgument("CommissioningTimeout", 0, UINT16_MAX, &mRequest.commissioningTimeout);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003C) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003C, 0x00000001, mRequest);
}
private:
chip::app::Clusters::AdministratorCommissioning::Commands::OpenBasicCommissioningWindow::Type mRequest;
};
/*
* Command OpenCommissioningWindow
*/
class AdministratorCommissioningOpenCommissioningWindow : public ClusterCommand
{
public:
AdministratorCommissioningOpenCommissioningWindow(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("open-commissioning-window", credsIssuerConfig)
{
AddArgument("CommissioningTimeout", 0, UINT16_MAX, &mRequest.commissioningTimeout);
AddArgument("PAKEVerifier", &mRequest.PAKEVerifier);
AddArgument("Discriminator", 0, UINT16_MAX, &mRequest.discriminator);
AddArgument("Iterations", 0, UINT32_MAX, &mRequest.iterations);
AddArgument("Salt", &mRequest.salt);
AddArgument("PasscodeID", 0, UINT16_MAX, &mRequest.passcodeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003C) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003C, 0x00000000, mRequest);
}
private:
chip::app::Clusters::AdministratorCommissioning::Commands::OpenCommissioningWindow::Type mRequest;
};
/*
* Command RevokeCommissioning
*/
class AdministratorCommissioningRevokeCommissioning : public ClusterCommand
{
public:
AdministratorCommissioningRevokeCommissioning(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("revoke-commissioning", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003C) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003C, 0x00000002, mRequest);
}
private:
chip::app::Clusters::AdministratorCommissioning::Commands::RevokeCommissioning::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster ApplicationBasic | 0x050D |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * VendorName | 0x0000 |
| * VendorId | 0x0001 |
| * ApplicationName | 0x0002 |
| * ProductId | 0x0003 |
| * ApplicationApp | 0x0004 |
| * ApplicationStatus | 0x0005 |
| * ApplicationVersion | 0x0006 |
| * AllowedVendorList | 0x0007 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster ApplicationLauncher | 0x050C |
|------------------------------------------------------------------------------|
| Commands: | |
| * HideAppRequest | 0x02 |
| * LaunchAppRequest | 0x00 |
| * StopAppRequest | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ApplicationLauncherList | 0x0000 |
| * ApplicationLauncherApp | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command HideAppRequest
*/
class ApplicationLauncherHideAppRequest : public ClusterCommand
{
public:
ApplicationLauncherHideAppRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("hide-app-request", credsIssuerConfig), mComplex_Application(&mRequest.application)
{
AddArgument("Application", &mComplex_Application);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050C) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050C, 0x00000002, mRequest);
}
private:
chip::app::Clusters::ApplicationLauncher::Commands::HideAppRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::Application::Type> mComplex_Application;
};
/*
* Command LaunchAppRequest
*/
class ApplicationLauncherLaunchAppRequest : public ClusterCommand
{
public:
ApplicationLauncherLaunchAppRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("launch-app-request", credsIssuerConfig), mComplex_Application(&mRequest.application)
{
AddArgument("Application", &mComplex_Application);
AddArgument("Data", &mRequest.data);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050C) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050C, 0x00000000, mRequest);
}
private:
chip::app::Clusters::ApplicationLauncher::Commands::LaunchAppRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::Application::Type> mComplex_Application;
};
/*
* Command StopAppRequest
*/
class ApplicationLauncherStopAppRequest : public ClusterCommand
{
public:
ApplicationLauncherStopAppRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("stop-app-request", credsIssuerConfig), mComplex_Application(&mRequest.application)
{
AddArgument("Application", &mComplex_Application);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050C) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050C, 0x00000001, mRequest);
}
private:
chip::app::Clusters::ApplicationLauncher::Commands::StopAppRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::Application::Type> mComplex_Application;
};
class WriteApplicationLauncherApplicationLauncherApp : public WriteAttribute
{
public:
WriteApplicationLauncherApplicationLauncherApp(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ApplicationLauncherApp", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "application-launcher-app");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteApplicationLauncherApplicationLauncherApp() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050C, 0x00000001, mValue);
}
private:
chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::Type mValue;
TypedComplexArgument<chip::app::Clusters::ApplicationLauncher::Structs::ApplicationEP::Type> mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster AudioOutput | 0x050B |
|------------------------------------------------------------------------------|
| Commands: | |
| * RenameOutputRequest | 0x01 |
| * SelectOutputRequest | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * AudioOutputList | 0x0000 |
| * CurrentAudioOutput | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command RenameOutputRequest
*/
class AudioOutputRenameOutputRequest : public ClusterCommand
{
public:
AudioOutputRenameOutputRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("rename-output-request", credsIssuerConfig)
{
AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
AddArgument("Name", &mRequest.name);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050B) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050B, 0x00000001, mRequest);
}
private:
chip::app::Clusters::AudioOutput::Commands::RenameOutputRequest::Type mRequest;
};
/*
* Command SelectOutputRequest
*/
class AudioOutputSelectOutputRequest : public ClusterCommand
{
public:
AudioOutputSelectOutputRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("select-output-request", credsIssuerConfig)
{
AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050B) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050B, 0x00000000, mRequest);
}
private:
chip::app::Clusters::AudioOutput::Commands::SelectOutputRequest::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster BarrierControl | 0x0103 |
|------------------------------------------------------------------------------|
| Commands: | |
| * BarrierControlGoToPercent | 0x00 |
| * BarrierControlStop | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * BarrierMovingState | 0x0001 |
| * BarrierSafetyStatus | 0x0002 |
| * BarrierCapabilities | 0x0003 |
| * BarrierPosition | 0x000A |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command BarrierControlGoToPercent
*/
class BarrierControlBarrierControlGoToPercent : public ClusterCommand
{
public:
BarrierControlBarrierControlGoToPercent(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("barrier-control-go-to-percent", credsIssuerConfig)
{
AddArgument("PercentOpen", 0, UINT8_MAX, &mRequest.percentOpen);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000103) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000103, 0x00000000, mRequest);
}
private:
chip::app::Clusters::BarrierControl::Commands::BarrierControlGoToPercent::Type mRequest;
};
/*
* Command BarrierControlStop
*/
class BarrierControlBarrierControlStop : public ClusterCommand
{
public:
BarrierControlBarrierControlStop(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("barrier-control-stop", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000103) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000103, 0x00000001, mRequest);
}
private:
chip::app::Clusters::BarrierControl::Commands::BarrierControlStop::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster Basic | 0x0028 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * DataModelRevision | 0x0000 |
| * VendorName | 0x0001 |
| * VendorID | 0x0002 |
| * ProductName | 0x0003 |
| * ProductID | 0x0004 |
| * NodeLabel | 0x0005 |
| * Location | 0x0006 |
| * HardwareVersion | 0x0007 |
| * HardwareVersionString | 0x0008 |
| * SoftwareVersion | 0x0009 |
| * SoftwareVersionString | 0x000A |
| * ManufacturingDate | 0x000B |
| * PartNumber | 0x000C |
| * ProductURL | 0x000D |
| * ProductLabel | 0x000E |
| * SerialNumber | 0x000F |
| * LocalConfigDisabled | 0x0010 |
| * Reachable | 0x0011 |
| * UniqueID | 0x0012 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * StartUp | 0x0000 |
| * ShutDown | 0x0001 |
| * Leave | 0x0002 |
| * ReachableChanged | 0x0003 |
\*----------------------------------------------------------------------------*/
class WriteBasicNodeLabel : public WriteAttribute
{
public:
WriteBasicNodeLabel(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NodeLabel", credsIssuerConfig)
{
AddArgument("attr-name", "node-label");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteBasicNodeLabel() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000028, 0x00000005, mValue);
}
private:
chip::CharSpan mValue;
};
class WriteBasicLocation : public WriteAttribute
{
public:
WriteBasicLocation(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Location", credsIssuerConfig)
{
AddArgument("attr-name", "location");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteBasicLocation() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000028, 0x00000006, mValue);
}
private:
chip::CharSpan mValue;
};
class WriteBasicLocalConfigDisabled : public WriteAttribute
{
public:
WriteBasicLocalConfigDisabled(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("LocalConfigDisabled", credsIssuerConfig)
{
AddArgument("attr-name", "local-config-disabled");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteBasicLocalConfigDisabled() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000028, 0x00000010, mValue);
}
private:
bool mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster BinaryInputBasic | 0x000F |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * OutOfService | 0x0051 |
| * PresentValue | 0x0055 |
| * StatusFlags | 0x006F |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteBinaryInputBasicOutOfService : public WriteAttribute
{
public:
WriteBinaryInputBasicOutOfService(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OutOfService", credsIssuerConfig)
{
AddArgument("attr-name", "out-of-service");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteBinaryInputBasicOutOfService() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000000F, 0x00000051, mValue);
}
private:
bool mValue;
};
class WriteBinaryInputBasicPresentValue : public WriteAttribute
{
public:
WriteBinaryInputBasicPresentValue(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("PresentValue", credsIssuerConfig)
{
AddArgument("attr-name", "present-value");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteBinaryInputBasicPresentValue() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000000F, 0x00000055, mValue);
}
private:
bool mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster Binding | 0x001E |
|------------------------------------------------------------------------------|
| Commands: | |
| * Bind | 0x00 |
| * Unbind | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command Bind
*/
class BindingBind : public ClusterCommand
{
public:
BindingBind(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("bind", credsIssuerConfig)
{
AddArgument("NodeId", 0, UINT64_MAX, &mRequest.nodeId);
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("EndpointId", 0, UINT16_MAX, &mRequest.endpointId);
AddArgument("ClusterId", 0, UINT32_MAX, &mRequest.clusterId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000001E) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000001E, 0x00000000, mRequest);
}
private:
chip::app::Clusters::Binding::Commands::Bind::Type mRequest;
};
/*
* Command Unbind
*/
class BindingUnbind : public ClusterCommand
{
public:
BindingUnbind(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("unbind", credsIssuerConfig)
{
AddArgument("NodeId", 0, UINT64_MAX, &mRequest.nodeId);
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("EndpointId", 0, UINT16_MAX, &mRequest.endpointId);
AddArgument("ClusterId", 0, UINT32_MAX, &mRequest.clusterId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000001E) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000001E, 0x00000001, mRequest);
}
private:
chip::app::Clusters::Binding::Commands::Unbind::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster BooleanState | 0x0045 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * StateValue | 0x0000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * StateChange | 0x0000 |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster BridgedActions | 0x0025 |
|------------------------------------------------------------------------------|
| Commands: | |
| * DisableAction | 0x0A |
| * DisableActionWithDuration | 0x0B |
| * EnableAction | 0x08 |
| * EnableActionWithDuration | 0x09 |
| * InstantAction | 0x00 |
| * InstantActionWithTransition | 0x01 |
| * PauseAction | 0x05 |
| * PauseActionWithDuration | 0x06 |
| * ResumeAction | 0x07 |
| * StartAction | 0x02 |
| * StartActionWithDuration | 0x03 |
| * StopAction | 0x04 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ActionList | 0x0000 |
| * EndpointList | 0x0001 |
| * SetupUrl | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * StateChanged | 0x0000 |
| * ActionFailed | 0x0001 |
\*----------------------------------------------------------------------------*/
/*
* Command DisableAction
*/
class BridgedActionsDisableAction : public ClusterCommand
{
public:
BridgedActionsDisableAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("disable-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x0000000A) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x0000000A, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::DisableAction::Type mRequest;
};
/*
* Command DisableActionWithDuration
*/
class BridgedActionsDisableActionWithDuration : public ClusterCommand
{
public:
BridgedActionsDisableActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("disable-action-with-duration", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x0000000B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x0000000B, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::DisableActionWithDuration::Type mRequest;
};
/*
* Command EnableAction
*/
class BridgedActionsEnableAction : public ClusterCommand
{
public:
BridgedActionsEnableAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("enable-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000008) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000008, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::EnableAction::Type mRequest;
};
/*
* Command EnableActionWithDuration
*/
class BridgedActionsEnableActionWithDuration : public ClusterCommand
{
public:
BridgedActionsEnableActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("enable-action-with-duration", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000009) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000009, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::EnableActionWithDuration::Type mRequest;
};
/*
* Command InstantAction
*/
class BridgedActionsInstantAction : public ClusterCommand
{
public:
BridgedActionsInstantAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("instant-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000000, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::InstantAction::Type mRequest;
};
/*
* Command InstantActionWithTransition
*/
class BridgedActionsInstantActionWithTransition : public ClusterCommand
{
public:
BridgedActionsInstantActionWithTransition(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("instant-action-with-transition", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000001, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::InstantActionWithTransition::Type mRequest;
};
/*
* Command PauseAction
*/
class BridgedActionsPauseAction : public ClusterCommand
{
public:
BridgedActionsPauseAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000005, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::PauseAction::Type mRequest;
};
/*
* Command PauseActionWithDuration
*/
class BridgedActionsPauseActionWithDuration : public ClusterCommand
{
public:
BridgedActionsPauseActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("pause-action-with-duration", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000006, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::PauseActionWithDuration::Type mRequest;
};
/*
* Command ResumeAction
*/
class BridgedActionsResumeAction : public ClusterCommand
{
public:
BridgedActionsResumeAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("resume-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000007, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::ResumeAction::Type mRequest;
};
/*
* Command StartAction
*/
class BridgedActionsStartAction : public ClusterCommand
{
public:
BridgedActionsStartAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("start-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000002, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::StartAction::Type mRequest;
};
/*
* Command StartActionWithDuration
*/
class BridgedActionsStartActionWithDuration : public ClusterCommand
{
public:
BridgedActionsStartActionWithDuration(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("start-action-with-duration", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
AddArgument("Duration", 0, UINT32_MAX, &mRequest.duration);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000003, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::StartActionWithDuration::Type mRequest;
};
/*
* Command StopAction
*/
class BridgedActionsStopAction : public ClusterCommand
{
public:
BridgedActionsStopAction(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-action", credsIssuerConfig)
{
AddArgument("ActionID", 0, UINT16_MAX, &mRequest.actionID);
AddArgument("InvokeID", 0, UINT32_MAX, &mRequest.invokeID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000025) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000025, 0x00000004, mRequest);
}
private:
chip::app::Clusters::BridgedActions::Commands::StopAction::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster BridgedDeviceBasic | 0x0039 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * VendorName | 0x0001 |
| * VendorID | 0x0002 |
| * ProductName | 0x0003 |
| * NodeLabel | 0x0005 |
| * HardwareVersion | 0x0007 |
| * HardwareVersionString | 0x0008 |
| * SoftwareVersion | 0x0009 |
| * SoftwareVersionString | 0x000A |
| * ManufacturingDate | 0x000B |
| * PartNumber | 0x000C |
| * ProductURL | 0x000D |
| * ProductLabel | 0x000E |
| * SerialNumber | 0x000F |
| * Reachable | 0x0011 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * StartUp | 0x0000 |
| * ShutDown | 0x0001 |
| * Leave | 0x0002 |
| * ReachableChanged | 0x0003 |
\*----------------------------------------------------------------------------*/
class WriteBridgedDeviceBasicNodeLabel : public WriteAttribute
{
public:
WriteBridgedDeviceBasicNodeLabel(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NodeLabel", credsIssuerConfig)
{
AddArgument("attr-name", "node-label");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteBridgedDeviceBasicNodeLabel() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000039, 0x00000005, mValue);
}
private:
chip::CharSpan mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster Channel | 0x0504 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ChangeChannelByNumberRequest | 0x02 |
| * ChangeChannelRequest | 0x00 |
| * SkipChannelRequest | 0x03 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ChannelList | 0x0000 |
| * ChannelLineup | 0x0001 |
| * CurrentChannel | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ChangeChannelByNumberRequest
*/
class ChannelChangeChannelByNumberRequest : public ClusterCommand
{
public:
ChannelChangeChannelByNumberRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("change-channel-by-number-request", credsIssuerConfig)
{
AddArgument("MajorNumber", 0, UINT16_MAX, &mRequest.majorNumber);
AddArgument("MinorNumber", 0, UINT16_MAX, &mRequest.minorNumber);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000504) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000504, 0x00000002, mRequest);
}
private:
chip::app::Clusters::Channel::Commands::ChangeChannelByNumberRequest::Type mRequest;
};
/*
* Command ChangeChannelRequest
*/
class ChannelChangeChannelRequest : public ClusterCommand
{
public:
ChannelChangeChannelRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("change-channel-request", credsIssuerConfig)
{
AddArgument("Match", &mRequest.match);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000504) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000504, 0x00000000, mRequest);
}
private:
chip::app::Clusters::Channel::Commands::ChangeChannelRequest::Type mRequest;
};
/*
* Command SkipChannelRequest
*/
class ChannelSkipChannelRequest : public ClusterCommand
{
public:
ChannelSkipChannelRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("skip-channel-request", credsIssuerConfig)
{
AddArgument("Count", 0, UINT16_MAX, &mRequest.count);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000504) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000504, 0x00000003, mRequest);
}
private:
chip::app::Clusters::Channel::Commands::SkipChannelRequest::Type mRequest;
};
class WriteChannelChannelLineup : public WriteAttribute
{
public:
WriteChannelChannelLineup(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ChannelLineup", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "channel-lineup");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteChannelChannelLineup() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000504, 0x00000001, mValue);
}
private:
chip::app::Clusters::Channel::Structs::LineupInfo::Type mValue;
TypedComplexArgument<chip::app::Clusters::Channel::Structs::LineupInfo::Type> mComplex;
};
class WriteChannelCurrentChannel : public WriteAttribute
{
public:
WriteChannelCurrentChannel(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("CurrentChannel", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "current-channel");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteChannelCurrentChannel() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000504, 0x00000002, mValue);
}
private:
chip::app::Clusters::Channel::Structs::ChannelInfo::Type mValue;
TypedComplexArgument<chip::app::Clusters::Channel::Structs::ChannelInfo::Type> mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster ColorControl | 0x0300 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ColorLoopSet | 0x44 |
| * EnhancedMoveHue | 0x41 |
| * EnhancedMoveToHue | 0x40 |
| * EnhancedMoveToHueAndSaturation | 0x43 |
| * EnhancedStepHue | 0x42 |
| * MoveColor | 0x08 |
| * MoveColorTemperature | 0x4B |
| * MoveHue | 0x01 |
| * MoveSaturation | 0x04 |
| * MoveToColor | 0x07 |
| * MoveToColorTemperature | 0x0A |
| * MoveToHue | 0x00 |
| * MoveToHueAndSaturation | 0x06 |
| * MoveToSaturation | 0x03 |
| * StepColor | 0x09 |
| * StepColorTemperature | 0x4C |
| * StepHue | 0x02 |
| * StepSaturation | 0x05 |
| * StopMoveStep | 0x47 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * CurrentHue | 0x0000 |
| * CurrentSaturation | 0x0001 |
| * RemainingTime | 0x0002 |
| * CurrentX | 0x0003 |
| * CurrentY | 0x0004 |
| * DriftCompensation | 0x0005 |
| * CompensationText | 0x0006 |
| * ColorTemperature | 0x0007 |
| * ColorMode | 0x0008 |
| * ColorControlOptions | 0x000F |
| * NumberOfPrimaries | 0x0010 |
| * Primary1X | 0x0011 |
| * Primary1Y | 0x0012 |
| * Primary1Intensity | 0x0013 |
| * Primary2X | 0x0015 |
| * Primary2Y | 0x0016 |
| * Primary2Intensity | 0x0017 |
| * Primary3X | 0x0019 |
| * Primary3Y | 0x001A |
| * Primary3Intensity | 0x001B |
| * Primary4X | 0x0020 |
| * Primary4Y | 0x0021 |
| * Primary4Intensity | 0x0022 |
| * Primary5X | 0x0024 |
| * Primary5Y | 0x0025 |
| * Primary5Intensity | 0x0026 |
| * Primary6X | 0x0028 |
| * Primary6Y | 0x0029 |
| * Primary6Intensity | 0x002A |
| * WhitePointX | 0x0030 |
| * WhitePointY | 0x0031 |
| * ColorPointRX | 0x0032 |
| * ColorPointRY | 0x0033 |
| * ColorPointRIntensity | 0x0034 |
| * ColorPointGX | 0x0036 |
| * ColorPointGY | 0x0037 |
| * ColorPointGIntensity | 0x0038 |
| * ColorPointBX | 0x003A |
| * ColorPointBY | 0x003B |
| * ColorPointBIntensity | 0x003C |
| * EnhancedCurrentHue | 0x4000 |
| * EnhancedColorMode | 0x4001 |
| * ColorLoopActive | 0x4002 |
| * ColorLoopDirection | 0x4003 |
| * ColorLoopTime | 0x4004 |
| * ColorLoopStartEnhancedHue | 0x4005 |
| * ColorLoopStoredEnhancedHue | 0x4006 |
| * ColorCapabilities | 0x400A |
| * ColorTempPhysicalMin | 0x400B |
| * ColorTempPhysicalMax | 0x400C |
| * CoupleColorTempToLevelMinMireds | 0x400D |
| * StartUpColorTemperatureMireds | 0x4010 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ColorLoopSet
*/
class ColorControlColorLoopSet : public ClusterCommand
{
public:
ColorControlColorLoopSet(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("color-loop-set", credsIssuerConfig)
{
AddArgument("UpdateFlags", 0, UINT8_MAX, &mRequest.updateFlags);
AddArgument("Action", 0, UINT8_MAX, &mRequest.action);
AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
AddArgument("Time", 0, UINT16_MAX, &mRequest.time);
AddArgument("StartHue", 0, UINT16_MAX, &mRequest.startHue);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000044) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000044, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::ColorLoopSet::Type mRequest;
};
/*
* Command EnhancedMoveHue
*/
class ColorControlEnhancedMoveHue : public ClusterCommand
{
public:
ColorControlEnhancedMoveHue(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("enhanced-move-hue", credsIssuerConfig)
{
AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
AddArgument("Rate", 0, UINT16_MAX, &mRequest.rate);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000041) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000041, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::EnhancedMoveHue::Type mRequest;
};
/*
* Command EnhancedMoveToHue
*/
class ColorControlEnhancedMoveToHue : public ClusterCommand
{
public:
ColorControlEnhancedMoveToHue(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("enhanced-move-to-hue", credsIssuerConfig)
{
AddArgument("EnhancedHue", 0, UINT16_MAX, &mRequest.enhancedHue);
AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000040) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000040, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHue::Type mRequest;
};
/*
* Command EnhancedMoveToHueAndSaturation
*/
class ColorControlEnhancedMoveToHueAndSaturation : public ClusterCommand
{
public:
ColorControlEnhancedMoveToHueAndSaturation(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("enhanced-move-to-hue-and-saturation", credsIssuerConfig)
{
AddArgument("EnhancedHue", 0, UINT16_MAX, &mRequest.enhancedHue);
AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000043) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000043, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::EnhancedMoveToHueAndSaturation::Type mRequest;
};
/*
* Command EnhancedStepHue
*/
class ColorControlEnhancedStepHue : public ClusterCommand
{
public:
ColorControlEnhancedStepHue(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("enhanced-step-hue", credsIssuerConfig)
{
AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
AddArgument("StepSize", 0, UINT16_MAX, &mRequest.stepSize);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000042) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000042, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::EnhancedStepHue::Type mRequest;
};
/*
* Command MoveColor
*/
class ColorControlMoveColor : public ClusterCommand
{
public:
ColorControlMoveColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-color", credsIssuerConfig)
{
AddArgument("RateX", INT16_MIN, INT16_MAX, &mRequest.rateX);
AddArgument("RateY", INT16_MIN, INT16_MAX, &mRequest.rateY);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000008) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000008, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveColor::Type mRequest;
};
/*
* Command MoveColorTemperature
*/
class ColorControlMoveColorTemperature : public ClusterCommand
{
public:
ColorControlMoveColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("move-color-temperature", credsIssuerConfig)
{
AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
AddArgument("Rate", 0, UINT16_MAX, &mRequest.rate);
AddArgument("ColorTemperatureMinimum", 0, UINT16_MAX, &mRequest.colorTemperatureMinimum);
AddArgument("ColorTemperatureMaximum", 0, UINT16_MAX, &mRequest.colorTemperatureMaximum);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x0000004B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x0000004B, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveColorTemperature::Type mRequest;
};
/*
* Command MoveHue
*/
class ColorControlMoveHue : public ClusterCommand
{
public:
ColorControlMoveHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-hue", credsIssuerConfig)
{
AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000001, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveHue::Type mRequest;
};
/*
* Command MoveSaturation
*/
class ColorControlMoveSaturation : public ClusterCommand
{
public:
ColorControlMoveSaturation(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-saturation", credsIssuerConfig)
{
AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000004, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveSaturation::Type mRequest;
};
/*
* Command MoveToColor
*/
class ColorControlMoveToColor : public ClusterCommand
{
public:
ColorControlMoveToColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-color", credsIssuerConfig)
{
AddArgument("ColorX", 0, UINT16_MAX, &mRequest.colorX);
AddArgument("ColorY", 0, UINT16_MAX, &mRequest.colorY);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000007, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveToColor::Type mRequest;
};
/*
* Command MoveToColorTemperature
*/
class ColorControlMoveToColorTemperature : public ClusterCommand
{
public:
ColorControlMoveToColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("move-to-color-temperature", credsIssuerConfig)
{
AddArgument("ColorTemperature", 0, UINT16_MAX, &mRequest.colorTemperature);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x0000000A) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x0000000A, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveToColorTemperature::Type mRequest;
};
/*
* Command MoveToHue
*/
class ColorControlMoveToHue : public ClusterCommand
{
public:
ColorControlMoveToHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-hue", credsIssuerConfig)
{
AddArgument("Hue", 0, UINT8_MAX, &mRequest.hue);
AddArgument("Direction", 0, UINT8_MAX, &mRequest.direction);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000000, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveToHue::Type mRequest;
};
/*
* Command MoveToHueAndSaturation
*/
class ColorControlMoveToHueAndSaturation : public ClusterCommand
{
public:
ColorControlMoveToHueAndSaturation(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("move-to-hue-and-saturation", credsIssuerConfig)
{
AddArgument("Hue", 0, UINT8_MAX, &mRequest.hue);
AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000006, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveToHueAndSaturation::Type mRequest;
};
/*
* Command MoveToSaturation
*/
class ColorControlMoveToSaturation : public ClusterCommand
{
public:
ColorControlMoveToSaturation(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("move-to-saturation", credsIssuerConfig)
{
AddArgument("Saturation", 0, UINT8_MAX, &mRequest.saturation);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000003, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::MoveToSaturation::Type mRequest;
};
/*
* Command StepColor
*/
class ColorControlStepColor : public ClusterCommand
{
public:
ColorControlStepColor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-color", credsIssuerConfig)
{
AddArgument("StepX", INT16_MIN, INT16_MAX, &mRequest.stepX);
AddArgument("StepY", INT16_MIN, INT16_MAX, &mRequest.stepY);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000009) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000009, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::StepColor::Type mRequest;
};
/*
* Command StepColorTemperature
*/
class ColorControlStepColorTemperature : public ClusterCommand
{
public:
ColorControlStepColorTemperature(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("step-color-temperature", credsIssuerConfig)
{
AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
AddArgument("StepSize", 0, UINT16_MAX, &mRequest.stepSize);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("ColorTemperatureMinimum", 0, UINT16_MAX, &mRequest.colorTemperatureMinimum);
AddArgument("ColorTemperatureMaximum", 0, UINT16_MAX, &mRequest.colorTemperatureMaximum);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x0000004C) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x0000004C, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::StepColorTemperature::Type mRequest;
};
/*
* Command StepHue
*/
class ColorControlStepHue : public ClusterCommand
{
public:
ColorControlStepHue(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-hue", credsIssuerConfig)
{
AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
AddArgument("TransitionTime", 0, UINT8_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000002, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::StepHue::Type mRequest;
};
/*
* Command StepSaturation
*/
class ColorControlStepSaturation : public ClusterCommand
{
public:
ColorControlStepSaturation(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-saturation", credsIssuerConfig)
{
AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
AddArgument("TransitionTime", 0, UINT8_MAX, &mRequest.transitionTime);
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000005, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::StepSaturation::Type mRequest;
};
/*
* Command StopMoveStep
*/
class ColorControlStopMoveStep : public ClusterCommand
{
public:
ColorControlStopMoveStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-move-step", credsIssuerConfig)
{
AddArgument("OptionsMask", 0, UINT8_MAX, &mRequest.optionsMask);
AddArgument("OptionsOverride", 0, UINT8_MAX, &mRequest.optionsOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000300) command (0x00000047) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000300, 0x00000047, mRequest);
}
private:
chip::app::Clusters::ColorControl::Commands::StopMoveStep::Type mRequest;
};
class WriteColorControlColorControlOptions : public WriteAttribute
{
public:
WriteColorControlColorControlOptions(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ColorControlOptions", credsIssuerConfig)
{
AddArgument("attr-name", "color-control-options");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorControlOptions() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000000F, mValue);
}
private:
uint8_t mValue;
};
class WriteColorControlWhitePointX : public WriteAttribute
{
public:
WriteColorControlWhitePointX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("WhitePointX", credsIssuerConfig)
{
AddArgument("attr-name", "white-point-x");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlWhitePointX() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000030, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlWhitePointY : public WriteAttribute
{
public:
WriteColorControlWhitePointY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("WhitePointY", credsIssuerConfig)
{
AddArgument("attr-name", "white-point-y");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlWhitePointY() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000031, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointRX : public WriteAttribute
{
public:
WriteColorControlColorPointRX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointRX", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-rx");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointRX() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000032, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointRY : public WriteAttribute
{
public:
WriteColorControlColorPointRY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointRY", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-ry");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointRY() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000033, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointRIntensity : public WriteAttribute
{
public:
WriteColorControlColorPointRIntensity(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ColorPointRIntensity", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-rintensity");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointRIntensity() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000034, mValue);
}
private:
uint8_t mValue;
};
class WriteColorControlColorPointGX : public WriteAttribute
{
public:
WriteColorControlColorPointGX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointGX", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-gx");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointGX() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000036, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointGY : public WriteAttribute
{
public:
WriteColorControlColorPointGY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointGY", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-gy");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointGY() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000037, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointGIntensity : public WriteAttribute
{
public:
WriteColorControlColorPointGIntensity(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ColorPointGIntensity", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-gintensity");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointGIntensity() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00000038, mValue);
}
private:
uint8_t mValue;
};
class WriteColorControlColorPointBX : public WriteAttribute
{
public:
WriteColorControlColorPointBX(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointBX", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-bx");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointBX() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000003A, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointBY : public WriteAttribute
{
public:
WriteColorControlColorPointBY(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("ColorPointBY", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-by");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointBY() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000003B, mValue);
}
private:
uint16_t mValue;
};
class WriteColorControlColorPointBIntensity : public WriteAttribute
{
public:
WriteColorControlColorPointBIntensity(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ColorPointBIntensity", credsIssuerConfig)
{
AddArgument("attr-name", "color-point-bintensity");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlColorPointBIntensity() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x0000003C, mValue);
}
private:
uint8_t mValue;
};
class WriteColorControlStartUpColorTemperatureMireds : public WriteAttribute
{
public:
WriteColorControlStartUpColorTemperatureMireds(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("StartUpColorTemperatureMireds", credsIssuerConfig)
{
AddArgument("attr-name", "start-up-color-temperature-mireds");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteColorControlStartUpColorTemperatureMireds() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000300, 0x00004010, mValue);
}
private:
uint16_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster ContentLauncher | 0x050A |
|------------------------------------------------------------------------------|
| Commands: | |
| * LaunchContentRequest | 0x00 |
| * LaunchURLRequest | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * AcceptHeaderList | 0x0000 |
| * SupportedStreamingProtocols | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command LaunchContentRequest
*/
class ContentLauncherLaunchContentRequest : public ClusterCommand
{
public:
ContentLauncherLaunchContentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("launch-content-request", credsIssuerConfig), mComplex_Search(&mRequest.search)
{
AddArgument("AutoPlay", 0, 1, &mRequest.autoPlay);
AddArgument("Data", &mRequest.data);
AddArgument("Search", &mComplex_Search);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050A) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050A, 0x00000000, mRequest);
}
private:
chip::app::Clusters::ContentLauncher::Commands::LaunchContentRequest::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::ContentLauncher::Structs::ContentSearch::Type>>
mComplex_Search;
};
/*
* Command LaunchURLRequest
*/
class ContentLauncherLaunchURLRequest : public ClusterCommand
{
public:
ContentLauncherLaunchURLRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("launch-urlrequest", credsIssuerConfig), mComplex_BrandingInformation(&mRequest.brandingInformation)
{
AddArgument("ContentURL", &mRequest.contentURL);
AddArgument("DisplayString", &mRequest.displayString);
AddArgument("BrandingInformation", &mComplex_BrandingInformation);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050A) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050A, 0x00000001, mRequest);
}
private:
chip::app::Clusters::ContentLauncher::Commands::LaunchURLRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type> mComplex_BrandingInformation;
};
class WriteContentLauncherSupportedStreamingProtocols : public WriteAttribute
{
public:
WriteContentLauncherSupportedStreamingProtocols(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("SupportedStreamingProtocols", credsIssuerConfig)
{
AddArgument("attr-name", "supported-streaming-protocols");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteContentLauncherSupportedStreamingProtocols() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050A, 0x00000001, mValue);
}
private:
uint32_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster Descriptor | 0x001D |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * DeviceList | 0x0000 |
| * ServerList | 0x0001 |
| * ClientList | 0x0002 |
| * PartsList | 0x0003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster DiagnosticLogs | 0x0032 |
|------------------------------------------------------------------------------|
| Commands: | |
| * RetrieveLogsRequest | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command RetrieveLogsRequest
*/
class DiagnosticLogsRetrieveLogsRequest : public ClusterCommand
{
public:
DiagnosticLogsRetrieveLogsRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("retrieve-logs-request", credsIssuerConfig)
{
AddArgument("Intent", 0, UINT8_MAX, &mRequest.intent);
AddArgument("RequestedProtocol", 0, UINT8_MAX, &mRequest.requestedProtocol);
AddArgument("TransferFileDesignator", &mRequest.transferFileDesignator);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000032) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000032, 0x00000000, mRequest);
}
private:
chip::app::Clusters::DiagnosticLogs::Commands::RetrieveLogsRequest::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster DoorLock | 0x0101 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ClearCredential | 0x26 |
| * ClearUser | 0x1D |
| * ClearWeekDaySchedule | 0x0D |
| * ClearYearDaySchedule | 0x10 |
| * GetCredentialStatus | 0x24 |
| * GetUser | 0x1B |
| * GetWeekDaySchedule | 0x0C |
| * GetYearDaySchedule | 0x0F |
| * LockDoor | 0x00 |
| * SetCredential | 0x22 |
| * SetUser | 0x1A |
| * SetWeekDaySchedule | 0x0B |
| * SetYearDaySchedule | 0x0E |
| * UnlockDoor | 0x01 |
| * UnlockWithTimeout | 0x03 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * LockState | 0x0000 |
| * LockType | 0x0001 |
| * ActuatorEnabled | 0x0002 |
| * DoorState | 0x0003 |
| * NumberOfTotalUsersSupported | 0x0011 |
| * NumberOfPINUsersSupported | 0x0012 |
| * NumberOfRFIDUsersSupported | 0x0013 |
| * NumberOfWeekDaySchedulesSupportedPerUser | 0x0014 |
| * NumberOfYearDaySchedulesSupportedPerUser | 0x0015 |
| * MaxPINCodeLength | 0x0017 |
| * MinPINCodeLength | 0x0018 |
| * MaxRFIDCodeLength | 0x0019 |
| * MinRFIDCodeLength | 0x001A |
| * Language | 0x0021 |
| * AutoRelockTime | 0x0023 |
| * SoundVolume | 0x0024 |
| * OperatingMode | 0x0025 |
| * SupportedOperatingModes | 0x0026 |
| * EnableOneTouchLocking | 0x0029 |
| * EnablePrivacyModeButton | 0x002B |
| * WrongCodeEntryLimit | 0x0030 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * DoorLockAlarm | 0x0000 |
| * DoorStateChange | 0x0001 |
| * LockOperation | 0x0002 |
| * LockOperationError | 0x0003 |
| * LockUserChange | 0x0004 |
\*----------------------------------------------------------------------------*/
/*
* Command ClearCredential
*/
class DoorLockClearCredential : public ClusterCommand
{
public:
DoorLockClearCredential(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("clear-credential", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
{
AddArgument("Credential", &mComplex_Credential);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000026) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000026, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::ClearCredential::Type mRequest;
TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::DoorLock::Structs::DlCredential::Type>>
mComplex_Credential;
};
/*
* Command ClearUser
*/
class DoorLockClearUser : public ClusterCommand
{
public:
DoorLockClearUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("clear-user", credsIssuerConfig)
{
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000001D) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000001D, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::ClearUser::Type mRequest;
};
/*
* Command ClearWeekDaySchedule
*/
class DoorLockClearWeekDaySchedule : public ClusterCommand
{
public:
DoorLockClearWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("clear-week-day-schedule", credsIssuerConfig)
{
AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000D) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000D, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::ClearWeekDaySchedule::Type mRequest;
};
/*
* Command ClearYearDaySchedule
*/
class DoorLockClearYearDaySchedule : public ClusterCommand
{
public:
DoorLockClearYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("clear-year-day-schedule", credsIssuerConfig)
{
AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000010) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000010, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::ClearYearDaySchedule::Type mRequest;
};
/*
* Command GetCredentialStatus
*/
class DoorLockGetCredentialStatus : public ClusterCommand
{
public:
DoorLockGetCredentialStatus(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-credential-status", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
{
AddArgument("Credential", &mComplex_Credential);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000024) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000024, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::GetCredentialStatus::Type mRequest;
TypedComplexArgument<chip::app::Clusters::DoorLock::Structs::DlCredential::Type> mComplex_Credential;
};
/*
* Command GetUser
*/
class DoorLockGetUser : public ClusterCommand
{
public:
DoorLockGetUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("get-user", credsIssuerConfig)
{
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000001B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000001B, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::GetUser::Type mRequest;
};
/*
* Command GetWeekDaySchedule
*/
class DoorLockGetWeekDaySchedule : public ClusterCommand
{
public:
DoorLockGetWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-week-day-schedule", credsIssuerConfig)
{
AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000C) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000C, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::GetWeekDaySchedule::Type mRequest;
};
/*
* Command GetYearDaySchedule
*/
class DoorLockGetYearDaySchedule : public ClusterCommand
{
public:
DoorLockGetYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-year-day-schedule", credsIssuerConfig)
{
AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000F) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000F, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::GetYearDaySchedule::Type mRequest;
};
/*
* Command LockDoor
*/
class DoorLockLockDoor : public ClusterCommand
{
public:
DoorLockLockDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("lock-door", credsIssuerConfig)
{
AddArgument("PinCode", &mRequest.pinCode);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000000, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::LockDoor::Type mRequest;
};
/*
* Command SetCredential
*/
class DoorLockSetCredential : public ClusterCommand
{
public:
DoorLockSetCredential(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("set-credential", credsIssuerConfig), mComplex_Credential(&mRequest.credential)
{
AddArgument("OperationType", 0, UINT8_MAX, &mRequest.operationType);
AddArgument("Credential", &mComplex_Credential);
AddArgument("CredentialData", &mRequest.credentialData);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
AddArgument("UserStatus", 0, UINT8_MAX, &mRequest.userStatus);
AddArgument("UserType", 0, UINT8_MAX, &mRequest.userType);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000022) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000022, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::SetCredential::Type mRequest;
TypedComplexArgument<chip::app::Clusters::DoorLock::Structs::DlCredential::Type> mComplex_Credential;
};
/*
* Command SetUser
*/
class DoorLockSetUser : public ClusterCommand
{
public:
DoorLockSetUser(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("set-user", credsIssuerConfig)
{
AddArgument("OperationType", 0, UINT8_MAX, &mRequest.operationType);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
AddArgument("UserName", &mRequest.userName);
AddArgument("UserUniqueId", 0, UINT32_MAX, &mRequest.userUniqueId);
AddArgument("UserStatus", 0, UINT8_MAX, &mRequest.userStatus);
AddArgument("UserType", 0, UINT8_MAX, &mRequest.userType);
AddArgument("CredentialRule", 0, UINT8_MAX, &mRequest.credentialRule);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000001A) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000001A, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::SetUser::Type mRequest;
};
/*
* Command SetWeekDaySchedule
*/
class DoorLockSetWeekDaySchedule : public ClusterCommand
{
public:
DoorLockSetWeekDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("set-week-day-schedule", credsIssuerConfig)
{
AddArgument("WeekDayIndex", 0, UINT8_MAX, &mRequest.weekDayIndex);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
AddArgument("DaysMask", 0, UINT8_MAX, &mRequest.daysMask);
AddArgument("StartHour", 0, UINT8_MAX, &mRequest.startHour);
AddArgument("StartMinute", 0, UINT8_MAX, &mRequest.startMinute);
AddArgument("EndHour", 0, UINT8_MAX, &mRequest.endHour);
AddArgument("EndMinute", 0, UINT8_MAX, &mRequest.endMinute);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000B, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::SetWeekDaySchedule::Type mRequest;
};
/*
* Command SetYearDaySchedule
*/
class DoorLockSetYearDaySchedule : public ClusterCommand
{
public:
DoorLockSetYearDaySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("set-year-day-schedule", credsIssuerConfig)
{
AddArgument("YearDayIndex", 0, UINT8_MAX, &mRequest.yearDayIndex);
AddArgument("UserIndex", 0, UINT16_MAX, &mRequest.userIndex);
AddArgument("LocalStartTime", 0, UINT32_MAX, &mRequest.localStartTime);
AddArgument("LocalEndTime", 0, UINT32_MAX, &mRequest.localEndTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x0000000E) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x0000000E, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::SetYearDaySchedule::Type mRequest;
};
/*
* Command UnlockDoor
*/
class DoorLockUnlockDoor : public ClusterCommand
{
public:
DoorLockUnlockDoor(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("unlock-door", credsIssuerConfig)
{
AddArgument("PinCode", &mRequest.pinCode);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000001, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::UnlockDoor::Type mRequest;
};
/*
* Command UnlockWithTimeout
*/
class DoorLockUnlockWithTimeout : public ClusterCommand
{
public:
DoorLockUnlockWithTimeout(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("unlock-with-timeout", credsIssuerConfig)
{
AddArgument("Timeout", 0, UINT16_MAX, &mRequest.timeout);
AddArgument("PinCode", &mRequest.pinCode);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000101) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000101, 0x00000003, mRequest);
}
private:
chip::app::Clusters::DoorLock::Commands::UnlockWithTimeout::Type mRequest;
};
class WriteDoorLockLanguage : public WriteAttribute
{
public:
WriteDoorLockLanguage(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Language", credsIssuerConfig)
{
AddArgument("attr-name", "language");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockLanguage() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000021, mValue);
}
private:
chip::CharSpan mValue;
};
class WriteDoorLockAutoRelockTime : public WriteAttribute
{
public:
WriteDoorLockAutoRelockTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("AutoRelockTime", credsIssuerConfig)
{
AddArgument("attr-name", "auto-relock-time");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockAutoRelockTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000023, mValue);
}
private:
uint32_t mValue;
};
class WriteDoorLockSoundVolume : public WriteAttribute
{
public:
WriteDoorLockSoundVolume(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("SoundVolume", credsIssuerConfig)
{
AddArgument("attr-name", "sound-volume");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockSoundVolume() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000024, mValue);
}
private:
uint8_t mValue;
};
class WriteDoorLockOperatingMode : public WriteAttribute
{
public:
WriteDoorLockOperatingMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OperatingMode", credsIssuerConfig)
{
AddArgument("attr-name", "operating-mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockOperatingMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000025, mValue);
}
private:
chip::app::Clusters::DoorLock::DlOperatingMode mValue;
};
class WriteDoorLockEnableOneTouchLocking : public WriteAttribute
{
public:
WriteDoorLockEnableOneTouchLocking(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("EnableOneTouchLocking", credsIssuerConfig)
{
AddArgument("attr-name", "enable-one-touch-locking");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockEnableOneTouchLocking() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000029, mValue);
}
private:
bool mValue;
};
class WriteDoorLockEnablePrivacyModeButton : public WriteAttribute
{
public:
WriteDoorLockEnablePrivacyModeButton(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("EnablePrivacyModeButton", credsIssuerConfig)
{
AddArgument("attr-name", "enable-privacy-mode-button");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockEnablePrivacyModeButton() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x0000002B, mValue);
}
private:
bool mValue;
};
class WriteDoorLockWrongCodeEntryLimit : public WriteAttribute
{
public:
WriteDoorLockWrongCodeEntryLimit(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("WrongCodeEntryLimit", credsIssuerConfig)
{
AddArgument("attr-name", "wrong-code-entry-limit");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteDoorLockWrongCodeEntryLimit() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000101, 0x00000030, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster ElectricalMeasurement | 0x0B04 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MeasurementType | 0x0000 |
| * TotalActivePower | 0x0304 |
| * RmsVoltage | 0x0505 |
| * RmsVoltageMin | 0x0506 |
| * RmsVoltageMax | 0x0507 |
| * RmsCurrent | 0x0508 |
| * RmsCurrentMin | 0x0509 |
| * RmsCurrentMax | 0x050A |
| * ActivePower | 0x050B |
| * ActivePowerMin | 0x050C |
| * ActivePowerMax | 0x050D |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster EthernetNetworkDiagnostics | 0x0037 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ResetCounts | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * PHYRate | 0x0000 |
| * FullDuplex | 0x0001 |
| * PacketRxCount | 0x0002 |
| * PacketTxCount | 0x0003 |
| * TxErrCount | 0x0004 |
| * CollisionCount | 0x0005 |
| * OverrunCount | 0x0006 |
| * CarrierDetect | 0x0007 |
| * TimeSinceReset | 0x0008 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ResetCounts
*/
class EthernetNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
EthernetNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("reset-counts", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000037) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000037, 0x00000000, mRequest);
}
private:
chip::app::Clusters::EthernetNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster FixedLabel | 0x0040 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * LabelList | 0x0000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster FlowMeasurement | 0x0404 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MeasuredValue | 0x0000 |
| * MinMeasuredValue | 0x0001 |
| * MaxMeasuredValue | 0x0002 |
| * Tolerance | 0x0003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster GeneralCommissioning | 0x0030 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ArmFailSafe | 0x00 |
| * CommissioningComplete | 0x04 |
| * SetRegulatoryConfig | 0x02 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Breadcrumb | 0x0000 |
| * BasicCommissioningInfo | 0x0001 |
| * RegulatoryConfig | 0x0002 |
| * LocationCapability | 0x0003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ArmFailSafe
*/
class GeneralCommissioningArmFailSafe : public ClusterCommand
{
public:
GeneralCommissioningArmFailSafe(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("arm-fail-safe", credsIssuerConfig)
{
AddArgument("ExpiryLengthSeconds", 0, UINT16_MAX, &mRequest.expiryLengthSeconds);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
AddArgument("TimeoutMs", 0, UINT32_MAX, &mRequest.timeoutMs);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000030) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000030, 0x00000000, mRequest);
}
private:
chip::app::Clusters::GeneralCommissioning::Commands::ArmFailSafe::Type mRequest;
};
/*
* Command CommissioningComplete
*/
class GeneralCommissioningCommissioningComplete : public ClusterCommand
{
public:
GeneralCommissioningCommissioningComplete(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("commissioning-complete", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000030) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000030, 0x00000004, mRequest);
}
private:
chip::app::Clusters::GeneralCommissioning::Commands::CommissioningComplete::Type mRequest;
};
/*
* Command SetRegulatoryConfig
*/
class GeneralCommissioningSetRegulatoryConfig : public ClusterCommand
{
public:
GeneralCommissioningSetRegulatoryConfig(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("set-regulatory-config", credsIssuerConfig)
{
AddArgument("Location", 0, UINT8_MAX, &mRequest.location);
AddArgument("CountryCode", &mRequest.countryCode);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
AddArgument("TimeoutMs", 0, UINT32_MAX, &mRequest.timeoutMs);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000030) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000030, 0x00000002, mRequest);
}
private:
chip::app::Clusters::GeneralCommissioning::Commands::SetRegulatoryConfig::Type mRequest;
};
class WriteGeneralCommissioningBreadcrumb : public WriteAttribute
{
public:
WriteGeneralCommissioningBreadcrumb(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("Breadcrumb", credsIssuerConfig)
{
AddArgument("attr-name", "breadcrumb");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteGeneralCommissioningBreadcrumb() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000030, 0x00000000, mValue);
}
private:
uint64_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster GeneralDiagnostics | 0x0033 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * NetworkInterfaces | 0x0000 |
| * RebootCount | 0x0001 |
| * UpTime | 0x0002 |
| * TotalOperationalHours | 0x0003 |
| * BootReasons | 0x0004 |
| * ActiveHardwareFaults | 0x0005 |
| * ActiveRadioFaults | 0x0006 |
| * ActiveNetworkFaults | 0x0007 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * HardwareFaultChange | 0x0000 |
| * RadioFaultChange | 0x0001 |
| * NetworkFaultChange | 0x0002 |
| * BootReason | 0x0003 |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster GroupKeyManagement | 0x003F |
|------------------------------------------------------------------------------|
| Commands: | |
| * KeySetRead | 0x01 |
| * KeySetReadAllIndices | 0x04 |
| * KeySetRemove | 0x03 |
| * KeySetWrite | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * GroupKeyMap | 0x0000 |
| * GroupTable | 0x0001 |
| * MaxGroupsPerFabric | 0x0002 |
| * MaxGroupKeysPerFabric | 0x0003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command KeySetRead
*/
class GroupKeyManagementKeySetRead : public ClusterCommand
{
public:
GroupKeyManagementKeySetRead(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("key-set-read", credsIssuerConfig)
{
AddArgument("GroupKeySetID", 0, UINT16_MAX, &mRequest.groupKeySetID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000001, mRequest);
}
private:
chip::app::Clusters::GroupKeyManagement::Commands::KeySetRead::Type mRequest;
};
/*
* Command KeySetReadAllIndices
*/
class GroupKeyManagementKeySetReadAllIndices : public ClusterCommand
{
public:
GroupKeyManagementKeySetReadAllIndices(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("key-set-read-all-indices", credsIssuerConfig), mComplex_GroupKeySetIDs(&mRequest.groupKeySetIDs)
{
AddArgument("GroupKeySetIDs", &mComplex_GroupKeySetIDs);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000004, mRequest);
}
private:
chip::app::Clusters::GroupKeyManagement::Commands::KeySetReadAllIndices::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const uint16_t>> mComplex_GroupKeySetIDs;
};
/*
* Command KeySetRemove
*/
class GroupKeyManagementKeySetRemove : public ClusterCommand
{
public:
GroupKeyManagementKeySetRemove(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("key-set-remove", credsIssuerConfig)
{
AddArgument("GroupKeySetID", 0, UINT16_MAX, &mRequest.groupKeySetID);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000003, mRequest);
}
private:
chip::app::Clusters::GroupKeyManagement::Commands::KeySetRemove::Type mRequest;
};
/*
* Command KeySetWrite
*/
class GroupKeyManagementKeySetWrite : public ClusterCommand
{
public:
GroupKeyManagementKeySetWrite(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("key-set-write", credsIssuerConfig), mComplex_GroupKeySet(&mRequest.groupKeySet)
{
AddArgument("GroupKeySet", &mComplex_GroupKeySet);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003F) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003F, 0x00000000, mRequest);
}
private:
chip::app::Clusters::GroupKeyManagement::Commands::KeySetWrite::Type mRequest;
TypedComplexArgument<chip::app::Clusters::GroupKeyManagement::Structs::GroupKeySetStruct::Type> mComplex_GroupKeySet;
};
class WriteGroupKeyManagementGroupKeyMap : public WriteAttribute
{
public:
WriteGroupKeyManagementGroupKeyMap(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("GroupKeyMap", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "group-key-map");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteGroupKeyManagementGroupKeyMap() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000003F, 0x00000000, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type> mValue;
TypedComplexArgument<
chip::app::DataModel::List<const chip::app::Clusters::GroupKeyManagement::Structs::GroupKeyMapStruct::Type>>
mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster Groups | 0x0004 |
|------------------------------------------------------------------------------|
| Commands: | |
| * AddGroup | 0x00 |
| * AddGroupIfIdentifying | 0x05 |
| * GetGroupMembership | 0x02 |
| * RemoveAllGroups | 0x04 |
| * RemoveGroup | 0x03 |
| * ViewGroup | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * NameSupport | 0x0000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command AddGroup
*/
class GroupsAddGroup : public ClusterCommand
{
public:
GroupsAddGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-group", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("GroupName", &mRequest.groupName);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000000, mRequest);
}
private:
chip::app::Clusters::Groups::Commands::AddGroup::Type mRequest;
};
/*
* Command AddGroupIfIdentifying
*/
class GroupsAddGroupIfIdentifying : public ClusterCommand
{
public:
GroupsAddGroupIfIdentifying(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("add-group-if-identifying", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("GroupName", &mRequest.groupName);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000005, mRequest);
}
private:
chip::app::Clusters::Groups::Commands::AddGroupIfIdentifying::Type mRequest;
};
/*
* Command GetGroupMembership
*/
class GroupsGetGroupMembership : public ClusterCommand
{
public:
GroupsGetGroupMembership(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-group-membership", credsIssuerConfig), mComplex_GroupList(&mRequest.groupList)
{
AddArgument("GroupList", &mComplex_GroupList);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000002, mRequest);
}
private:
chip::app::Clusters::Groups::Commands::GetGroupMembership::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const uint16_t>> mComplex_GroupList;
};
/*
* Command RemoveAllGroups
*/
class GroupsRemoveAllGroups : public ClusterCommand
{
public:
GroupsRemoveAllGroups(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-all-groups", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000004, mRequest);
}
private:
chip::app::Clusters::Groups::Commands::RemoveAllGroups::Type mRequest;
};
/*
* Command RemoveGroup
*/
class GroupsRemoveGroup : public ClusterCommand
{
public:
GroupsRemoveGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-group", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000003, mRequest);
}
private:
chip::app::Clusters::Groups::Commands::RemoveGroup::Type mRequest;
};
/*
* Command ViewGroup
*/
class GroupsViewGroup : public ClusterCommand
{
public:
GroupsViewGroup(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("view-group", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000004) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000004, 0x00000001, mRequest);
}
private:
chip::app::Clusters::Groups::Commands::ViewGroup::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster Identify | 0x0003 |
|------------------------------------------------------------------------------|
| Commands: | |
| * Identify | 0x00 |
| * IdentifyQuery | 0x01 |
| * TriggerEffect | 0x40 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * IdentifyTime | 0x0000 |
| * IdentifyType | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command Identify
*/
class IdentifyIdentify : public ClusterCommand
{
public:
IdentifyIdentify(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("identify", credsIssuerConfig)
{
AddArgument("IdentifyTime", 0, UINT16_MAX, &mRequest.identifyTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000003) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000003, 0x00000000, mRequest);
}
private:
chip::app::Clusters::Identify::Commands::Identify::Type mRequest;
};
/*
* Command IdentifyQuery
*/
class IdentifyIdentifyQuery : public ClusterCommand
{
public:
IdentifyIdentifyQuery(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("identify-query", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000003) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000003, 0x00000001, mRequest);
}
private:
chip::app::Clusters::Identify::Commands::IdentifyQuery::Type mRequest;
};
/*
* Command TriggerEffect
*/
class IdentifyTriggerEffect : public ClusterCommand
{
public:
IdentifyTriggerEffect(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("trigger-effect", credsIssuerConfig)
{
AddArgument("EffectIdentifier", 0, UINT8_MAX, &mRequest.effectIdentifier);
AddArgument("EffectVariant", 0, UINT8_MAX, &mRequest.effectVariant);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000003) command (0x00000040) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000003, 0x00000040, mRequest);
}
private:
chip::app::Clusters::Identify::Commands::TriggerEffect::Type mRequest;
};
class WriteIdentifyIdentifyTime : public WriteAttribute
{
public:
WriteIdentifyIdentifyTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("IdentifyTime", credsIssuerConfig)
{
AddArgument("attr-name", "identify-time");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteIdentifyIdentifyTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000003, 0x00000000, mValue);
}
private:
uint16_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster IlluminanceMeasurement | 0x0400 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MeasuredValue | 0x0000 |
| * MinMeasuredValue | 0x0001 |
| * MaxMeasuredValue | 0x0002 |
| * Tolerance | 0x0003 |
| * LightSensorType | 0x0004 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster KeypadInput | 0x0509 |
|------------------------------------------------------------------------------|
| Commands: | |
| * SendKeyRequest | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command SendKeyRequest
*/
class KeypadInputSendKeyRequest : public ClusterCommand
{
public:
KeypadInputSendKeyRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("send-key-request", credsIssuerConfig)
{
AddArgument("KeyCode", 0, UINT8_MAX, &mRequest.keyCode);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000509) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000509, 0x00000000, mRequest);
}
private:
chip::app::Clusters::KeypadInput::Commands::SendKeyRequest::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster LevelControl | 0x0008 |
|------------------------------------------------------------------------------|
| Commands: | |
| * Move | 0x01 |
| * MoveToLevel | 0x00 |
| * MoveToLevelWithOnOff | 0x04 |
| * MoveWithOnOff | 0x05 |
| * Step | 0x02 |
| * StepWithOnOff | 0x06 |
| * Stop | 0x03 |
| * StopWithOnOff | 0x07 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * CurrentLevel | 0x0000 |
| * RemainingTime | 0x0001 |
| * MinLevel | 0x0002 |
| * MaxLevel | 0x0003 |
| * CurrentFrequency | 0x0004 |
| * MinFrequency | 0x0005 |
| * MaxFrequency | 0x0006 |
| * Options | 0x000F |
| * OnOffTransitionTime | 0x0010 |
| * OnLevel | 0x0011 |
| * OnTransitionTime | 0x0012 |
| * OffTransitionTime | 0x0013 |
| * DefaultMoveRate | 0x0014 |
| * StartUpCurrentLevel | 0x4000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command Move
*/
class LevelControlMove : public ClusterCommand
{
public:
LevelControlMove(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move", credsIssuerConfig)
{
AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000001, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::Move::Type mRequest;
};
/*
* Command MoveToLevel
*/
class LevelControlMoveToLevel : public ClusterCommand
{
public:
LevelControlMoveToLevel(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-to-level", credsIssuerConfig)
{
AddArgument("Level", 0, UINT8_MAX, &mRequest.level);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000000, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::MoveToLevel::Type mRequest;
};
/*
* Command MoveToLevelWithOnOff
*/
class LevelControlMoveToLevelWithOnOff : public ClusterCommand
{
public:
LevelControlMoveToLevelWithOnOff(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("move-to-level-with-on-off", credsIssuerConfig)
{
AddArgument("Level", 0, UINT8_MAX, &mRequest.level);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000004, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::MoveToLevelWithOnOff::Type mRequest;
};
/*
* Command MoveWithOnOff
*/
class LevelControlMoveWithOnOff : public ClusterCommand
{
public:
LevelControlMoveWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("move-with-on-off", credsIssuerConfig)
{
AddArgument("MoveMode", 0, UINT8_MAX, &mRequest.moveMode);
AddArgument("Rate", 0, UINT8_MAX, &mRequest.rate);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000005, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::MoveWithOnOff::Type mRequest;
};
/*
* Command Step
*/
class LevelControlStep : public ClusterCommand
{
public:
LevelControlStep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step", credsIssuerConfig)
{
AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000002, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::Step::Type mRequest;
};
/*
* Command StepWithOnOff
*/
class LevelControlStepWithOnOff : public ClusterCommand
{
public:
LevelControlStepWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("step-with-on-off", credsIssuerConfig)
{
AddArgument("StepMode", 0, UINT8_MAX, &mRequest.stepMode);
AddArgument("StepSize", 0, UINT8_MAX, &mRequest.stepSize);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000006, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::StepWithOnOff::Type mRequest;
};
/*
* Command Stop
*/
class LevelControlStop : public ClusterCommand
{
public:
LevelControlStop(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop", credsIssuerConfig)
{
AddArgument("OptionMask", 0, UINT8_MAX, &mRequest.optionMask);
AddArgument("OptionOverride", 0, UINT8_MAX, &mRequest.optionOverride);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000003, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::Stop::Type mRequest;
};
/*
* Command StopWithOnOff
*/
class LevelControlStopWithOnOff : public ClusterCommand
{
public:
LevelControlStopWithOnOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-with-on-off", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000008) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000008, 0x00000007, mRequest);
}
private:
chip::app::Clusters::LevelControl::Commands::StopWithOnOff::Type mRequest;
};
class WriteLevelControlOptions : public WriteAttribute
{
public:
WriteLevelControlOptions(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Options", credsIssuerConfig)
{
AddArgument("attr-name", "options");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlOptions() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x0000000F, mValue);
}
private:
uint8_t mValue;
};
class WriteLevelControlOnOffTransitionTime : public WriteAttribute
{
public:
WriteLevelControlOnOffTransitionTime(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OnOffTransitionTime", credsIssuerConfig)
{
AddArgument("attr-name", "on-off-transition-time");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlOnOffTransitionTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000010, mValue);
}
private:
uint16_t mValue;
};
class WriteLevelControlOnLevel : public WriteAttribute
{
public:
WriteLevelControlOnLevel(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OnLevel", credsIssuerConfig)
{
AddArgument("attr-name", "on-level");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlOnLevel() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000011, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
class WriteLevelControlOnTransitionTime : public WriteAttribute
{
public:
WriteLevelControlOnTransitionTime(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OnTransitionTime", credsIssuerConfig)
{
AddArgument("attr-name", "on-transition-time");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlOnTransitionTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000012, mValue);
}
private:
chip::app::DataModel::Nullable<uint16_t> mValue;
};
class WriteLevelControlOffTransitionTime : public WriteAttribute
{
public:
WriteLevelControlOffTransitionTime(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OffTransitionTime", credsIssuerConfig)
{
AddArgument("attr-name", "off-transition-time");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlOffTransitionTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000013, mValue);
}
private:
chip::app::DataModel::Nullable<uint16_t> mValue;
};
class WriteLevelControlDefaultMoveRate : public WriteAttribute
{
public:
WriteLevelControlDefaultMoveRate(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("DefaultMoveRate", credsIssuerConfig)
{
AddArgument("attr-name", "default-move-rate");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlDefaultMoveRate() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00000014, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
class WriteLevelControlStartUpCurrentLevel : public WriteAttribute
{
public:
WriteLevelControlStartUpCurrentLevel(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("StartUpCurrentLevel", credsIssuerConfig)
{
AddArgument("attr-name", "start-up-current-level");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteLevelControlStartUpCurrentLevel() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000008, 0x00004000, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster LocalizationConfiguration | 0x002B |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ActiveLocale | 0x0001 |
| * SupportedLocales | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteLocalizationConfigurationActiveLocale : public WriteAttribute
{
public:
WriteLocalizationConfigurationActiveLocale(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ActiveLocale", credsIssuerConfig)
{
AddArgument("attr-name", "active-locale");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteLocalizationConfigurationActiveLocale() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000002B, 0x00000001, mValue);
}
private:
chip::CharSpan mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster LowPower | 0x0508 |
|------------------------------------------------------------------------------|
| Commands: | |
| * Sleep | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command Sleep
*/
class LowPowerSleep : public ClusterCommand
{
public:
LowPowerSleep(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("sleep", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000508) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000508, 0x00000000, mRequest);
}
private:
chip::app::Clusters::LowPower::Commands::Sleep::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster MediaInput | 0x0507 |
|------------------------------------------------------------------------------|
| Commands: | |
| * HideInputStatusRequest | 0x02 |
| * RenameInputRequest | 0x03 |
| * SelectInputRequest | 0x00 |
| * ShowInputStatusRequest | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MediaInputList | 0x0000 |
| * CurrentMediaInput | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command HideInputStatusRequest
*/
class MediaInputHideInputStatusRequest : public ClusterCommand
{
public:
MediaInputHideInputStatusRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("hide-input-status-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000002, mRequest);
}
private:
chip::app::Clusters::MediaInput::Commands::HideInputStatusRequest::Type mRequest;
};
/*
* Command RenameInputRequest
*/
class MediaInputRenameInputRequest : public ClusterCommand
{
public:
MediaInputRenameInputRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("rename-input-request", credsIssuerConfig)
{
AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
AddArgument("Name", &mRequest.name);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000003, mRequest);
}
private:
chip::app::Clusters::MediaInput::Commands::RenameInputRequest::Type mRequest;
};
/*
* Command SelectInputRequest
*/
class MediaInputSelectInputRequest : public ClusterCommand
{
public:
MediaInputSelectInputRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("select-input-request", credsIssuerConfig)
{
AddArgument("Index", 0, UINT8_MAX, &mRequest.index);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000000, mRequest);
}
private:
chip::app::Clusters::MediaInput::Commands::SelectInputRequest::Type mRequest;
};
/*
* Command ShowInputStatusRequest
*/
class MediaInputShowInputStatusRequest : public ClusterCommand
{
public:
MediaInputShowInputStatusRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("show-input-status-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000507) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000507, 0x00000001, mRequest);
}
private:
chip::app::Clusters::MediaInput::Commands::ShowInputStatusRequest::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster MediaPlayback | 0x0506 |
|------------------------------------------------------------------------------|
| Commands: | |
| * FastForwardRequest | 0x07 |
| * NextRequest | 0x05 |
| * PauseRequest | 0x01 |
| * PlayRequest | 0x00 |
| * PreviousRequest | 0x04 |
| * RewindRequest | 0x06 |
| * SeekRequest | 0x0B |
| * SkipBackwardRequest | 0x09 |
| * SkipForwardRequest | 0x08 |
| * StartOverRequest | 0x03 |
| * StopRequest | 0x02 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * PlaybackState | 0x0000 |
| * StartTime | 0x0001 |
| * Duration | 0x0002 |
| * Position | 0x0003 |
| * PlaybackSpeed | 0x0004 |
| * SeekRangeEnd | 0x0005 |
| * SeekRangeStart | 0x0006 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command FastForwardRequest
*/
class MediaPlaybackFastForwardRequest : public ClusterCommand
{
public:
MediaPlaybackFastForwardRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("fast-forward-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000007, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::FastForwardRequest::Type mRequest;
};
/*
* Command NextRequest
*/
class MediaPlaybackNextRequest : public ClusterCommand
{
public:
MediaPlaybackNextRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("next-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000005, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::NextRequest::Type mRequest;
};
/*
* Command PauseRequest
*/
class MediaPlaybackPauseRequest : public ClusterCommand
{
public:
MediaPlaybackPauseRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("pause-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000001, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::PauseRequest::Type mRequest;
};
/*
* Command PlayRequest
*/
class MediaPlaybackPlayRequest : public ClusterCommand
{
public:
MediaPlaybackPlayRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("play-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000000, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::PlayRequest::Type mRequest;
};
/*
* Command PreviousRequest
*/
class MediaPlaybackPreviousRequest : public ClusterCommand
{
public:
MediaPlaybackPreviousRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("previous-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000004, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::PreviousRequest::Type mRequest;
};
/*
* Command RewindRequest
*/
class MediaPlaybackRewindRequest : public ClusterCommand
{
public:
MediaPlaybackRewindRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("rewind-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000006, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::RewindRequest::Type mRequest;
};
/*
* Command SeekRequest
*/
class MediaPlaybackSeekRequest : public ClusterCommand
{
public:
MediaPlaybackSeekRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("seek-request", credsIssuerConfig)
{
AddArgument("Position", 0, UINT64_MAX, &mRequest.position);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x0000000B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x0000000B, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::SeekRequest::Type mRequest;
};
/*
* Command SkipBackwardRequest
*/
class MediaPlaybackSkipBackwardRequest : public ClusterCommand
{
public:
MediaPlaybackSkipBackwardRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("skip-backward-request", credsIssuerConfig)
{
AddArgument("DeltaPositionMilliseconds", 0, UINT64_MAX, &mRequest.deltaPositionMilliseconds);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000009) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000009, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::SkipBackwardRequest::Type mRequest;
};
/*
* Command SkipForwardRequest
*/
class MediaPlaybackSkipForwardRequest : public ClusterCommand
{
public:
MediaPlaybackSkipForwardRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("skip-forward-request", credsIssuerConfig)
{
AddArgument("DeltaPositionMilliseconds", 0, UINT64_MAX, &mRequest.deltaPositionMilliseconds);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000008) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000008, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::SkipForwardRequest::Type mRequest;
};
/*
* Command StartOverRequest
*/
class MediaPlaybackStartOverRequest : public ClusterCommand
{
public:
MediaPlaybackStartOverRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("start-over-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000003, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::StartOverRequest::Type mRequest;
};
/*
* Command StopRequest
*/
class MediaPlaybackStopRequest : public ClusterCommand
{
public:
MediaPlaybackStopRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000506) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000506, 0x00000002, mRequest);
}
private:
chip::app::Clusters::MediaPlayback::Commands::StopRequest::Type mRequest;
};
class WriteMediaPlaybackPosition : public WriteAttribute
{
public:
WriteMediaPlaybackPosition(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("Position", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "position");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteMediaPlaybackPosition() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000506, 0x00000003, mValue);
}
private:
chip::app::Clusters::MediaPlayback::Structs::PlaybackPosition::Type mValue;
TypedComplexArgument<chip::app::Clusters::MediaPlayback::Structs::PlaybackPosition::Type> mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster ModeSelect | 0x0050 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ChangeToMode | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * CurrentMode | 0x0000 |
| * SupportedModes | 0x0001 |
| * OnMode | 0x0002 |
| * StartUpMode | 0x0003 |
| * Description | 0x0004 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ChangeToMode
*/
class ModeSelectChangeToMode : public ClusterCommand
{
public:
ModeSelectChangeToMode(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("change-to-mode", credsIssuerConfig)
{
AddArgument("NewMode", 0, UINT8_MAX, &mRequest.newMode);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000050) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000050, 0x00000000, mRequest);
}
private:
chip::app::Clusters::ModeSelect::Commands::ChangeToMode::Type mRequest;
};
class WriteModeSelectOnMode : public WriteAttribute
{
public:
WriteModeSelectOnMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OnMode", credsIssuerConfig)
{
AddArgument("attr-name", "on-mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteModeSelectOnMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000050, 0x00000002, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster NetworkCommissioning | 0x0031 |
|------------------------------------------------------------------------------|
| Commands: | |
| * AddOrUpdateThreadNetwork | 0x03 |
| * AddOrUpdateWiFiNetwork | 0x02 |
| * ConnectNetwork | 0x06 |
| * RemoveNetwork | 0x04 |
| * ReorderNetwork | 0x08 |
| * ScanNetworks | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MaxNetworks | 0x0000 |
| * Networks | 0x0001 |
| * ScanMaxTimeSeconds | 0x0002 |
| * ConnectMaxTimeSeconds | 0x0003 |
| * InterfaceEnabled | 0x0004 |
| * LastNetworkingStatus | 0x0005 |
| * LastNetworkID | 0x0006 |
| * LastConnectErrorValue | 0x0007 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command AddOrUpdateThreadNetwork
*/
class NetworkCommissioningAddOrUpdateThreadNetwork : public ClusterCommand
{
public:
NetworkCommissioningAddOrUpdateThreadNetwork(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("add-or-update-thread-network", credsIssuerConfig)
{
AddArgument("OperationalDataset", &mRequest.operationalDataset);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000003, mRequest);
}
private:
chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateThreadNetwork::Type mRequest;
};
/*
* Command AddOrUpdateWiFiNetwork
*/
class NetworkCommissioningAddOrUpdateWiFiNetwork : public ClusterCommand
{
public:
NetworkCommissioningAddOrUpdateWiFiNetwork(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("add-or-update-wi-fi-network", credsIssuerConfig)
{
AddArgument("Ssid", &mRequest.ssid);
AddArgument("Credentials", &mRequest.credentials);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000002, mRequest);
}
private:
chip::app::Clusters::NetworkCommissioning::Commands::AddOrUpdateWiFiNetwork::Type mRequest;
};
/*
* Command ConnectNetwork
*/
class NetworkCommissioningConnectNetwork : public ClusterCommand
{
public:
NetworkCommissioningConnectNetwork(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("connect-network", credsIssuerConfig)
{
AddArgument("NetworkID", &mRequest.networkID);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000006, mRequest);
}
private:
chip::app::Clusters::NetworkCommissioning::Commands::ConnectNetwork::Type mRequest;
};
/*
* Command RemoveNetwork
*/
class NetworkCommissioningRemoveNetwork : public ClusterCommand
{
public:
NetworkCommissioningRemoveNetwork(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("remove-network", credsIssuerConfig)
{
AddArgument("NetworkID", &mRequest.networkID);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000004, mRequest);
}
private:
chip::app::Clusters::NetworkCommissioning::Commands::RemoveNetwork::Type mRequest;
};
/*
* Command ReorderNetwork
*/
class NetworkCommissioningReorderNetwork : public ClusterCommand
{
public:
NetworkCommissioningReorderNetwork(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("reorder-network", credsIssuerConfig)
{
AddArgument("NetworkID", &mRequest.networkID);
AddArgument("NetworkIndex", 0, UINT8_MAX, &mRequest.networkIndex);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000008) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000008, mRequest);
}
private:
chip::app::Clusters::NetworkCommissioning::Commands::ReorderNetwork::Type mRequest;
};
/*
* Command ScanNetworks
*/
class NetworkCommissioningScanNetworks : public ClusterCommand
{
public:
NetworkCommissioningScanNetworks(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("scan-networks", credsIssuerConfig)
{
AddArgument("Ssid", &mRequest.ssid);
AddArgument("Breadcrumb", 0, UINT64_MAX, &mRequest.breadcrumb);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000031) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000031, 0x00000000, mRequest);
}
private:
chip::app::Clusters::NetworkCommissioning::Commands::ScanNetworks::Type mRequest;
};
class WriteNetworkCommissioningInterfaceEnabled : public WriteAttribute
{
public:
WriteNetworkCommissioningInterfaceEnabled(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("InterfaceEnabled", credsIssuerConfig)
{
AddArgument("attr-name", "interface-enabled");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteNetworkCommissioningInterfaceEnabled() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000031, 0x00000004, mValue);
}
private:
bool mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster OtaSoftwareUpdateProvider | 0x0029 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ApplyUpdateRequest | 0x02 |
| * NotifyUpdateApplied | 0x04 |
| * QueryImage | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ApplyUpdateRequest
*/
class OtaSoftwareUpdateProviderApplyUpdateRequest : public ClusterCommand
{
public:
OtaSoftwareUpdateProviderApplyUpdateRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("apply-update-request", credsIssuerConfig)
{
AddArgument("UpdateToken", &mRequest.updateToken);
AddArgument("NewVersion", 0, UINT32_MAX, &mRequest.newVersion);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000029) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000029, 0x00000002, mRequest);
}
private:
chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Type mRequest;
};
/*
* Command NotifyUpdateApplied
*/
class OtaSoftwareUpdateProviderNotifyUpdateApplied : public ClusterCommand
{
public:
OtaSoftwareUpdateProviderNotifyUpdateApplied(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("notify-update-applied", credsIssuerConfig)
{
AddArgument("UpdateToken", &mRequest.updateToken);
AddArgument("SoftwareVersion", 0, UINT32_MAX, &mRequest.softwareVersion);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000029) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000029, 0x00000004, mRequest);
}
private:
chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Type mRequest;
};
/*
* Command QueryImage
*/
class OtaSoftwareUpdateProviderQueryImage : public ClusterCommand
{
public:
OtaSoftwareUpdateProviderQueryImage(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("query-image", credsIssuerConfig), mComplex_ProtocolsSupported(&mRequest.protocolsSupported)
{
AddArgument("VendorId", 0, UINT16_MAX, &mRequest.vendorId);
AddArgument("ProductId", 0, UINT16_MAX, &mRequest.productId);
AddArgument("SoftwareVersion", 0, UINT32_MAX, &mRequest.softwareVersion);
AddArgument("ProtocolsSupported", &mComplex_ProtocolsSupported);
AddArgument("HardwareVersion", 0, UINT16_MAX, &mRequest.hardwareVersion);
AddArgument("Location", &mRequest.location);
AddArgument("RequestorCanConsent", 0, 1, &mRequest.requestorCanConsent);
AddArgument("MetadataForProvider", &mRequest.metadataForProvider);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000029) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000029, 0x00000000, mRequest);
}
private:
chip::app::Clusters::OtaSoftwareUpdateProvider::Commands::QueryImage::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateProvider::OTADownloadProtocol>>
mComplex_ProtocolsSupported;
};
/*----------------------------------------------------------------------------*\
| Cluster OtaSoftwareUpdateRequestor | 0x002A |
|------------------------------------------------------------------------------|
| Commands: | |
| * AnnounceOtaProvider | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * DefaultOtaProviders | 0x0000 |
| * UpdatePossible | 0x0001 |
| * UpdateState | 0x0002 |
| * UpdateStateProgress | 0x0003 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * StateTransition | 0x0000 |
| * VersionApplied | 0x0001 |
| * DownloadError | 0x0002 |
\*----------------------------------------------------------------------------*/
/*
* Command AnnounceOtaProvider
*/
class OtaSoftwareUpdateRequestorAnnounceOtaProvider : public ClusterCommand
{
public:
OtaSoftwareUpdateRequestorAnnounceOtaProvider(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("announce-ota-provider", credsIssuerConfig)
{
AddArgument("ProviderNodeId", 0, UINT64_MAX, &mRequest.providerNodeId);
AddArgument("VendorId", 0, UINT16_MAX, &mRequest.vendorId);
AddArgument("AnnouncementReason", 0, UINT8_MAX, &mRequest.announcementReason);
AddArgument("MetadataForNode", &mRequest.metadataForNode);
AddArgument("Endpoint", 0, UINT16_MAX, &mRequest.endpoint);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000002A) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000002A, 0x00000000, mRequest);
}
private:
chip::app::Clusters::OtaSoftwareUpdateRequestor::Commands::AnnounceOtaProvider::Type mRequest;
};
class WriteOtaSoftwareUpdateRequestorDefaultOtaProviders : public WriteAttribute
{
public:
WriteOtaSoftwareUpdateRequestorDefaultOtaProviders(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("DefaultOtaProviders", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "default-ota-providers");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteOtaSoftwareUpdateRequestorDefaultOtaProviders() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000002A, 0x00000000, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type> mValue;
TypedComplexArgument<
chip::app::DataModel::List<const chip::app::Clusters::OtaSoftwareUpdateRequestor::Structs::ProviderLocation::Type>>
mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster OccupancySensing | 0x0406 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Occupancy | 0x0000 |
| * OccupancySensorType | 0x0001 |
| * OccupancySensorTypeBitmap | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster OnOff | 0x0006 |
|------------------------------------------------------------------------------|
| Commands: | |
| * Off | 0x00 |
| * OffWithEffect | 0x40 |
| * On | 0x01 |
| * OnWithRecallGlobalScene | 0x41 |
| * OnWithTimedOff | 0x42 |
| * Toggle | 0x02 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * OnOff | 0x0000 |
| * GlobalSceneControl | 0x4000 |
| * OnTime | 0x4001 |
| * OffWaitTime | 0x4002 |
| * StartUpOnOff | 0x4003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command Off
*/
class OnOffOff : public ClusterCommand
{
public:
OnOffOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("off", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000000, mRequest);
}
private:
chip::app::Clusters::OnOff::Commands::Off::Type mRequest;
};
/*
* Command OffWithEffect
*/
class OnOffOffWithEffect : public ClusterCommand
{
public:
OnOffOffWithEffect(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("off-with-effect", credsIssuerConfig)
{
AddArgument("EffectId", 0, UINT8_MAX, &mRequest.effectId);
AddArgument("EffectVariant", 0, UINT8_MAX, &mRequest.effectVariant);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000040) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000040, mRequest);
}
private:
chip::app::Clusters::OnOff::Commands::OffWithEffect::Type mRequest;
};
/*
* Command On
*/
class OnOffOn : public ClusterCommand
{
public:
OnOffOn(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("on", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000001, mRequest);
}
private:
chip::app::Clusters::OnOff::Commands::On::Type mRequest;
};
/*
* Command OnWithRecallGlobalScene
*/
class OnOffOnWithRecallGlobalScene : public ClusterCommand
{
public:
OnOffOnWithRecallGlobalScene(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("on-with-recall-global-scene", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000041) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000041, mRequest);
}
private:
chip::app::Clusters::OnOff::Commands::OnWithRecallGlobalScene::Type mRequest;
};
/*
* Command OnWithTimedOff
*/
class OnOffOnWithTimedOff : public ClusterCommand
{
public:
OnOffOnWithTimedOff(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("on-with-timed-off", credsIssuerConfig)
{
AddArgument("OnOffControl", 0, UINT8_MAX, &mRequest.onOffControl);
AddArgument("OnTime", 0, UINT16_MAX, &mRequest.onTime);
AddArgument("OffWaitTime", 0, UINT16_MAX, &mRequest.offWaitTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000042) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000042, mRequest);
}
private:
chip::app::Clusters::OnOff::Commands::OnWithTimedOff::Type mRequest;
};
/*
* Command Toggle
*/
class OnOffToggle : public ClusterCommand
{
public:
OnOffToggle(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("toggle", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000006) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000006, 0x00000002, mRequest);
}
private:
chip::app::Clusters::OnOff::Commands::Toggle::Type mRequest;
};
class WriteOnOffOnTime : public WriteAttribute
{
public:
WriteOnOffOnTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OnTime", credsIssuerConfig)
{
AddArgument("attr-name", "on-time");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteOnOffOnTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000006, 0x00004001, mValue);
}
private:
uint16_t mValue;
};
class WriteOnOffOffWaitTime : public WriteAttribute
{
public:
WriteOnOffOffWaitTime(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OffWaitTime", credsIssuerConfig)
{
AddArgument("attr-name", "off-wait-time");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteOnOffOffWaitTime() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000006, 0x00004002, mValue);
}
private:
uint16_t mValue;
};
class WriteOnOffStartUpOnOff : public WriteAttribute
{
public:
WriteOnOffStartUpOnOff(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("StartUpOnOff", credsIssuerConfig)
{
AddArgument("attr-name", "start-up-on-off");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteOnOffStartUpOnOff() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000006, 0x00004003, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster OnOffSwitchConfiguration | 0x0007 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * SwitchType | 0x0000 |
| * SwitchActions | 0x0010 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteOnOffSwitchConfigurationSwitchActions : public WriteAttribute
{
public:
WriteOnOffSwitchConfigurationSwitchActions(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("SwitchActions", credsIssuerConfig)
{
AddArgument("attr-name", "switch-actions");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteOnOffSwitchConfigurationSwitchActions() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000007, 0x00000010, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster OperationalCredentials | 0x003E |
|------------------------------------------------------------------------------|
| Commands: | |
| * AddNOC | 0x06 |
| * AddTrustedRootCertificate | 0x0B |
| * AttestationRequest | 0x00 |
| * CSRRequest | 0x04 |
| * CertificateChainRequest | 0x02 |
| * RemoveFabric | 0x0A |
| * RemoveTrustedRootCertificate | 0x0C |
| * UpdateFabricLabel | 0x09 |
| * UpdateNOC | 0x07 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * NOCs | 0x0000 |
| * FabricsList | 0x0001 |
| * SupportedFabrics | 0x0002 |
| * CommissionedFabrics | 0x0003 |
| * TrustedRootCertificates | 0x0004 |
| * CurrentFabricIndex | 0x0005 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command AddNOC
*/
class OperationalCredentialsAddNOC : public ClusterCommand
{
public:
OperationalCredentialsAddNOC(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("add-noc", credsIssuerConfig)
{
AddArgument("NOCValue", &mRequest.NOCValue);
AddArgument("ICACValue", &mRequest.ICACValue);
AddArgument("IPKValue", &mRequest.IPKValue);
AddArgument("CaseAdminNode", 0, UINT64_MAX, &mRequest.caseAdminNode);
AddArgument("AdminVendorId", 0, UINT16_MAX, &mRequest.adminVendorId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000006, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::AddNOC::Type mRequest;
};
/*
* Command AddTrustedRootCertificate
*/
class OperationalCredentialsAddTrustedRootCertificate : public ClusterCommand
{
public:
OperationalCredentialsAddTrustedRootCertificate(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("add-trusted-root-certificate", credsIssuerConfig)
{
AddArgument("RootCertificate", &mRequest.rootCertificate);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x0000000B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x0000000B, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::AddTrustedRootCertificate::Type mRequest;
};
/*
* Command AttestationRequest
*/
class OperationalCredentialsAttestationRequest : public ClusterCommand
{
public:
OperationalCredentialsAttestationRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("attestation-request", credsIssuerConfig)
{
AddArgument("AttestationNonce", &mRequest.attestationNonce);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000000, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::AttestationRequest::Type mRequest;
};
/*
* Command CSRRequest
*/
class OperationalCredentialsCSRRequest : public ClusterCommand
{
public:
OperationalCredentialsCSRRequest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("csrrequest", credsIssuerConfig)
{
AddArgument("CSRNonce", &mRequest.CSRNonce);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000004, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::CSRRequest::Type mRequest;
};
/*
* Command CertificateChainRequest
*/
class OperationalCredentialsCertificateChainRequest : public ClusterCommand
{
public:
OperationalCredentialsCertificateChainRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("certificate-chain-request", credsIssuerConfig)
{
AddArgument("CertificateType", 0, UINT8_MAX, &mRequest.certificateType);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000002, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::CertificateChainRequest::Type mRequest;
};
/*
* Command RemoveFabric
*/
class OperationalCredentialsRemoveFabric : public ClusterCommand
{
public:
OperationalCredentialsRemoveFabric(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("remove-fabric", credsIssuerConfig)
{
AddArgument("FabricIndex", 0, UINT8_MAX, &mRequest.fabricIndex);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x0000000A) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x0000000A, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::RemoveFabric::Type mRequest;
};
/*
* Command RemoveTrustedRootCertificate
*/
class OperationalCredentialsRemoveTrustedRootCertificate : public ClusterCommand
{
public:
OperationalCredentialsRemoveTrustedRootCertificate(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("remove-trusted-root-certificate", credsIssuerConfig)
{
AddArgument("TrustedRootIdentifier", &mRequest.trustedRootIdentifier);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x0000000C) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x0000000C, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::RemoveTrustedRootCertificate::Type mRequest;
};
/*
* Command UpdateFabricLabel
*/
class OperationalCredentialsUpdateFabricLabel : public ClusterCommand
{
public:
OperationalCredentialsUpdateFabricLabel(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("update-fabric-label", credsIssuerConfig)
{
AddArgument("Label", &mRequest.label);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000009) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000009, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::UpdateFabricLabel::Type mRequest;
};
/*
* Command UpdateNOC
*/
class OperationalCredentialsUpdateNOC : public ClusterCommand
{
public:
OperationalCredentialsUpdateNOC(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("update-noc", credsIssuerConfig)
{
AddArgument("NOCValue", &mRequest.NOCValue);
AddArgument("ICACValue", &mRequest.ICACValue);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000003E) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000003E, 0x00000007, mRequest);
}
private:
chip::app::Clusters::OperationalCredentials::Commands::UpdateNOC::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster PowerSource | 0x002F |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Status | 0x0000 |
| * Order | 0x0001 |
| * Description | 0x0002 |
| * BatteryVoltage | 0x000B |
| * BatteryPercentRemaining | 0x000C |
| * BatteryTimeRemaining | 0x000D |
| * BatteryChargeLevel | 0x000E |
| * ActiveBatteryFaults | 0x0012 |
| * BatteryChargeState | 0x001A |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster PowerSourceConfiguration | 0x002E |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Sources | 0x0000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster PressureMeasurement | 0x0403 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MeasuredValue | 0x0000 |
| * MinMeasuredValue | 0x0001 |
| * MaxMeasuredValue | 0x0002 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster PumpConfigurationAndControl | 0x0200 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MaxPressure | 0x0000 |
| * MaxSpeed | 0x0001 |
| * MaxFlow | 0x0002 |
| * MinConstPressure | 0x0003 |
| * MaxConstPressure | 0x0004 |
| * MinCompPressure | 0x0005 |
| * MaxCompPressure | 0x0006 |
| * MinConstSpeed | 0x0007 |
| * MaxConstSpeed | 0x0008 |
| * MinConstFlow | 0x0009 |
| * MaxConstFlow | 0x000A |
| * MinConstTemp | 0x000B |
| * MaxConstTemp | 0x000C |
| * PumpStatus | 0x0010 |
| * EffectiveOperationMode | 0x0011 |
| * EffectiveControlMode | 0x0012 |
| * Capacity | 0x0013 |
| * Speed | 0x0014 |
| * LifetimeRunningHours | 0x0015 |
| * Power | 0x0016 |
| * LifetimeEnergyConsumed | 0x0017 |
| * OperationMode | 0x0020 |
| * ControlMode | 0x0021 |
| * AlarmMask | 0x0022 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * SupplyVoltageLow | 0x0000 |
| * SupplyVoltageHigh | 0x0001 |
| * PowerMissingPhase | 0x0002 |
| * SystemPressureLow | 0x0003 |
| * SystemPressureHigh | 0x0004 |
| * DryRunning | 0x0005 |
| * MotorTemperatureHigh | 0x0006 |
| * PumpMotorFatalFailure | 0x0007 |
| * ElectronicTemperatureHigh | 0x0008 |
| * PumpBlocked | 0x0009 |
| * SensorFailure | 0x000A |
| * ElectronicNonFatalFailure | 0x000B |
| * ElectronicFatalFailure | 0x000C |
| * GeneralFault | 0x000D |
| * Leakage | 0x000E |
| * AirDetection | 0x000F |
| * TurbineOperation | 0x0010 |
\*----------------------------------------------------------------------------*/
class WritePumpConfigurationAndControlLifetimeRunningHours : public WriteAttribute
{
public:
WritePumpConfigurationAndControlLifetimeRunningHours(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("LifetimeRunningHours", credsIssuerConfig)
{
AddArgument("attr-name", "lifetime-running-hours");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WritePumpConfigurationAndControlLifetimeRunningHours() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000015, mValue);
}
private:
chip::app::DataModel::Nullable<uint32_t> mValue;
};
class WritePumpConfigurationAndControlLifetimeEnergyConsumed : public WriteAttribute
{
public:
WritePumpConfigurationAndControlLifetimeEnergyConsumed(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("LifetimeEnergyConsumed", credsIssuerConfig)
{
AddArgument("attr-name", "lifetime-energy-consumed");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WritePumpConfigurationAndControlLifetimeEnergyConsumed() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000017, mValue);
}
private:
chip::app::DataModel::Nullable<uint32_t> mValue;
};
class WritePumpConfigurationAndControlOperationMode : public WriteAttribute
{
public:
WritePumpConfigurationAndControlOperationMode(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OperationMode", credsIssuerConfig)
{
AddArgument("attr-name", "operation-mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WritePumpConfigurationAndControlOperationMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000020, mValue);
}
private:
uint8_t mValue;
};
class WritePumpConfigurationAndControlControlMode : public WriteAttribute
{
public:
WritePumpConfigurationAndControlControlMode(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ControlMode", credsIssuerConfig)
{
AddArgument("attr-name", "control-mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WritePumpConfigurationAndControlControlMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000200, 0x00000021, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster RelativeHumidityMeasurement | 0x0405 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MeasuredValue | 0x0000 |
| * MinMeasuredValue | 0x0001 |
| * MaxMeasuredValue | 0x0002 |
| * Tolerance | 0x0003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster Scenes | 0x0005 |
|------------------------------------------------------------------------------|
| Commands: | |
| * AddScene | 0x00 |
| * GetSceneMembership | 0x06 |
| * RecallScene | 0x05 |
| * RemoveAllScenes | 0x03 |
| * RemoveScene | 0x02 |
| * StoreScene | 0x04 |
| * ViewScene | 0x01 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * SceneCount | 0x0000 |
| * CurrentScene | 0x0001 |
| * CurrentGroup | 0x0002 |
| * SceneValid | 0x0003 |
| * NameSupport | 0x0004 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command AddScene
*/
class ScenesAddScene : public ClusterCommand
{
public:
ScenesAddScene(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("add-scene", credsIssuerConfig), mComplex_ExtensionFieldSets(&mRequest.extensionFieldSets)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
AddArgument("SceneName", &mRequest.sceneName);
AddArgument("ExtensionFieldSets", &mComplex_ExtensionFieldSets);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000000, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::AddScene::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::Scenes::Structs::SceneExtensionFieldSet::Type>>
mComplex_ExtensionFieldSets;
};
/*
* Command GetSceneMembership
*/
class ScenesGetSceneMembership : public ClusterCommand
{
public:
ScenesGetSceneMembership(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-scene-membership", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000006) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000006, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::GetSceneMembership::Type mRequest;
};
/*
* Command RecallScene
*/
class ScenesRecallScene : public ClusterCommand
{
public:
ScenesRecallScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("recall-scene", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
AddArgument("TransitionTime", 0, UINT16_MAX, &mRequest.transitionTime);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000005, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::RecallScene::Type mRequest;
};
/*
* Command RemoveAllScenes
*/
class ScenesRemoveAllScenes : public ClusterCommand
{
public:
ScenesRemoveAllScenes(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-all-scenes", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000003, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::RemoveAllScenes::Type mRequest;
};
/*
* Command RemoveScene
*/
class ScenesRemoveScene : public ClusterCommand
{
public:
ScenesRemoveScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("remove-scene", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000002, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::RemoveScene::Type mRequest;
};
/*
* Command StoreScene
*/
class ScenesStoreScene : public ClusterCommand
{
public:
ScenesStoreScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("store-scene", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000004, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::StoreScene::Type mRequest;
};
/*
* Command ViewScene
*/
class ScenesViewScene : public ClusterCommand
{
public:
ScenesViewScene(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("view-scene", credsIssuerConfig)
{
AddArgument("GroupId", 0, UINT16_MAX, &mRequest.groupId);
AddArgument("SceneId", 0, UINT8_MAX, &mRequest.sceneId);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000005) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000005, 0x00000001, mRequest);
}
private:
chip::app::Clusters::Scenes::Commands::ViewScene::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster SoftwareDiagnostics | 0x0034 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ResetWatermarks | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * ThreadMetrics | 0x0000 |
| * CurrentHeapFree | 0x0001 |
| * CurrentHeapUsed | 0x0002 |
| * CurrentHeapHighWatermark | 0x0003 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * SoftwareFault | 0x0000 |
\*----------------------------------------------------------------------------*/
/*
* Command ResetWatermarks
*/
class SoftwareDiagnosticsResetWatermarks : public ClusterCommand
{
public:
SoftwareDiagnosticsResetWatermarks(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("reset-watermarks", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000034) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000034, 0x00000000, mRequest);
}
private:
chip::app::Clusters::SoftwareDiagnostics::Commands::ResetWatermarks::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster Switch | 0x003B |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * NumberOfPositions | 0x0000 |
| * CurrentPosition | 0x0001 |
| * MultiPressMax | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * SwitchLatched | 0x0000 |
| * InitialPress | 0x0001 |
| * LongPress | 0x0002 |
| * ShortRelease | 0x0003 |
| * LongRelease | 0x0004 |
| * MultiPressOngoing | 0x0005 |
| * MultiPressComplete | 0x0006 |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster TargetNavigator | 0x0505 |
|------------------------------------------------------------------------------|
| Commands: | |
| * NavigateTargetRequest | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * TargetNavigatorList | 0x0000 |
| * CurrentNavigatorTarget | 0x0001 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command NavigateTargetRequest
*/
class TargetNavigatorNavigateTargetRequest : public ClusterCommand
{
public:
TargetNavigatorNavigateTargetRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("navigate-target-request", credsIssuerConfig)
{
AddArgument("Target", 0, UINT8_MAX, &mRequest.target);
AddArgument("Data", &mRequest.data);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000505) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000505, 0x00000000, mRequest);
}
private:
chip::app::Clusters::TargetNavigator::Commands::NavigateTargetRequest::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster TemperatureMeasurement | 0x0402 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * MeasuredValue | 0x0000 |
| * MinMeasuredValue | 0x0001 |
| * MaxMeasuredValue | 0x0002 |
| * Tolerance | 0x0003 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster TestCluster | 0x050F |
|------------------------------------------------------------------------------|
| Commands: | |
| * SimpleStructEchoRequest | 0x11 |
| * Test | 0x00 |
| * TestAddArguments | 0x04 |
| * TestEmitTestEventRequest | 0x14 |
| * TestEnumsRequest | 0x0E |
| * TestListInt8UArgumentRequest | 0x0A |
| * TestListInt8UReverseRequest | 0x0D |
| * TestListNestedStructListArgumentRequest | 0x0C |
| * TestListStructArgumentRequest | 0x09 |
| * TestNestedStructArgumentRequest | 0x08 |
| * TestNestedStructListArgumentRequest | 0x0B |
| * TestNotHandled | 0x01 |
| * TestNullableOptionalRequest | 0x0F |
| * TestSimpleOptionalArgumentRequest | 0x13 |
| * TestSpecific | 0x02 |
| * TestStructArgumentRequest | 0x07 |
| * TestUnknownCommand | 0x03 |
| * TimedInvokeRequest | 0x12 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Boolean | 0x0000 |
| * Bitmap8 | 0x0001 |
| * Bitmap16 | 0x0002 |
| * Bitmap32 | 0x0003 |
| * Bitmap64 | 0x0004 |
| * Int8u | 0x0005 |
| * Int16u | 0x0006 |
| * Int24u | 0x0007 |
| * Int32u | 0x0008 |
| * Int40u | 0x0009 |
| * Int48u | 0x000A |
| * Int56u | 0x000B |
| * Int64u | 0x000C |
| * Int8s | 0x000D |
| * Int16s | 0x000E |
| * Int24s | 0x000F |
| * Int32s | 0x0010 |
| * Int40s | 0x0011 |
| * Int48s | 0x0012 |
| * Int56s | 0x0013 |
| * Int64s | 0x0014 |
| * Enum8 | 0x0015 |
| * Enum16 | 0x0016 |
| * FloatSingle | 0x0017 |
| * FloatDouble | 0x0018 |
| * OctetString | 0x0019 |
| * ListInt8u | 0x001A |
| * ListOctetString | 0x001B |
| * ListStructOctetString | 0x001C |
| * LongOctetString | 0x001D |
| * CharString | 0x001E |
| * LongCharString | 0x001F |
| * EpochUs | 0x0020 |
| * EpochS | 0x0021 |
| * VendorId | 0x0022 |
| * ListNullablesAndOptionalsStruct | 0x0023 |
| * EnumAttr | 0x0024 |
| * StructAttr | 0x0025 |
| * RangeRestrictedInt8u | 0x0026 |
| * RangeRestrictedInt8s | 0x0027 |
| * RangeRestrictedInt16u | 0x0028 |
| * RangeRestrictedInt16s | 0x0029 |
| * ListLongOctetString | 0x002A |
| * TimedWriteBoolean | 0x0030 |
| * GeneralErrorBoolean | 0x0031 |
| * ClusterErrorBoolean | 0x0032 |
| * Unsupported | 0x00FF |
| * NullableBoolean | 0x8000 |
| * NullableBitmap8 | 0x8001 |
| * NullableBitmap16 | 0x8002 |
| * NullableBitmap32 | 0x8003 |
| * NullableBitmap64 | 0x8004 |
| * NullableInt8u | 0x8005 |
| * NullableInt16u | 0x8006 |
| * NullableInt24u | 0x8007 |
| * NullableInt32u | 0x8008 |
| * NullableInt40u | 0x8009 |
| * NullableInt48u | 0x800A |
| * NullableInt56u | 0x800B |
| * NullableInt64u | 0x800C |
| * NullableInt8s | 0x800D |
| * NullableInt16s | 0x800E |
| * NullableInt24s | 0x800F |
| * NullableInt32s | 0x8010 |
| * NullableInt40s | 0x8011 |
| * NullableInt48s | 0x8012 |
| * NullableInt56s | 0x8013 |
| * NullableInt64s | 0x8014 |
| * NullableEnum8 | 0x8015 |
| * NullableEnum16 | 0x8016 |
| * NullableFloatSingle | 0x8017 |
| * NullableFloatDouble | 0x8018 |
| * NullableOctetString | 0x8019 |
| * NullableCharString | 0x801E |
| * NullableEnumAttr | 0x8024 |
| * NullableStruct | 0x8025 |
| * NullableRangeRestrictedInt8u | 0x8026 |
| * NullableRangeRestrictedInt8s | 0x8027 |
| * NullableRangeRestrictedInt16u | 0x8028 |
| * NullableRangeRestrictedInt16s | 0x8029 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * TestEvent | 0x0001 |
| * TestFabricScopedEvent | 0x0002 |
\*----------------------------------------------------------------------------*/
/*
* Command SimpleStructEchoRequest
*/
class TestClusterSimpleStructEchoRequest : public ClusterCommand
{
public:
TestClusterSimpleStructEchoRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("simple-struct-echo-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000011) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000011, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mComplex_Arg1;
};
/*
* Command Test
*/
class TestClusterTest : public ClusterCommand
{
public:
TestClusterTest(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000000, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::Test::Type mRequest;
};
/*
* Command TestAddArguments
*/
class TestClusterTestAddArguments : public ClusterCommand
{
public:
TestClusterTestAddArguments(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-add-arguments", credsIssuerConfig)
{
AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000004, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestAddArguments::Type mRequest;
};
/*
* Command TestEmitTestEventRequest
*/
class TestClusterTestEmitTestEventRequest : public ClusterCommand
{
public:
TestClusterTestEmitTestEventRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-emit-test-event-request", credsIssuerConfig)
{
AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
AddArgument("Arg3", 0, 1, &mRequest.arg3);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000014) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000014, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestEmitTestEventRequest::Type mRequest;
};
/*
* Command TestEnumsRequest
*/
class TestClusterTestEnumsRequest : public ClusterCommand
{
public:
TestClusterTestEnumsRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-enums-request", credsIssuerConfig)
{
AddArgument("Arg1", 0, UINT16_MAX, &mRequest.arg1);
AddArgument("Arg2", 0, UINT8_MAX, &mRequest.arg2);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000E) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000E, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestEnumsRequest::Type mRequest;
};
/*
* Command TestListInt8UArgumentRequest
*/
class TestClusterTestListInt8UArgumentRequest : public ClusterCommand
{
public:
TestClusterTestListInt8UArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-list-int8uargument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000A) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000A, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Arg1;
};
/*
* Command TestListInt8UReverseRequest
*/
class TestClusterTestListInt8UReverseRequest : public ClusterCommand
{
public:
TestClusterTestListInt8UReverseRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-list-int8ureverse-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000D) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000D, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Arg1;
};
/*
* Command TestListNestedStructListArgumentRequest
*/
class TestClusterTestListNestedStructListArgumentRequest : public ClusterCommand
{
public:
TestClusterTestListNestedStructListArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-list-nested-struct-list-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000C) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000C, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::NestedStructList::Type>>
mComplex_Arg1;
};
/*
* Command TestListStructArgumentRequest
*/
class TestClusterTestListStructArgumentRequest : public ClusterCommand
{
public:
TestClusterTestListStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-list-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000009) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000009, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type>>
mComplex_Arg1;
};
/*
* Command TestNestedStructArgumentRequest
*/
class TestClusterTestNestedStructArgumentRequest : public ClusterCommand
{
public:
TestClusterTestNestedStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-nested-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000008) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000008, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::NestedStruct::Type> mComplex_Arg1;
};
/*
* Command TestNestedStructListArgumentRequest
*/
class TestClusterTestNestedStructListArgumentRequest : public ClusterCommand
{
public:
TestClusterTestNestedStructListArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-nested-struct-list-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000B) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000B, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::NestedStructList::Type> mComplex_Arg1;
};
/*
* Command TestNotHandled
*/
class TestClusterTestNotHandled : public ClusterCommand
{
public:
TestClusterTestNotHandled(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test-not-handled", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000001, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestNotHandled::Type mRequest;
};
/*
* Command TestNullableOptionalRequest
*/
class TestClusterTestNullableOptionalRequest : public ClusterCommand
{
public:
TestClusterTestNullableOptionalRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-nullable-optional-request", credsIssuerConfig)
{
AddArgument("Arg1", 0, UINT8_MAX, &mRequest.arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x0000000F) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x0000000F, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type mRequest;
};
/*
* Command TestSimpleOptionalArgumentRequest
*/
class TestClusterTestSimpleOptionalArgumentRequest : public ClusterCommand
{
public:
TestClusterTestSimpleOptionalArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-simple-optional-argument-request", credsIssuerConfig)
{
AddArgument("Arg1", 0, 1, &mRequest.arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000013) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000013, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type mRequest;
};
/*
* Command TestSpecific
*/
class TestClusterTestSpecific : public ClusterCommand
{
public:
TestClusterTestSpecific(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("test-specific", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000002, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestSpecific::Type mRequest;
};
/*
* Command TestStructArgumentRequest
*/
class TestClusterTestStructArgumentRequest : public ClusterCommand
{
public:
TestClusterTestStructArgumentRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-struct-argument-request", credsIssuerConfig), mComplex_Arg1(&mRequest.arg1)
{
AddArgument("Arg1", &mComplex_Arg1);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000007, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type mRequest;
TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mComplex_Arg1;
};
/*
* Command TestUnknownCommand
*/
class TestClusterTestUnknownCommand : public ClusterCommand
{
public:
TestClusterTestUnknownCommand(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("test-unknown-command", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000003, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TestUnknownCommand::Type mRequest;
};
/*
* Command TimedInvokeRequest
*/
class TestClusterTimedInvokeRequest : public ClusterCommand
{
public:
TestClusterTimedInvokeRequest(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("timed-invoke-request", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000012) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x0000050F, 0x00000012, mRequest);
}
private:
chip::app::Clusters::TestCluster::Commands::TimedInvokeRequest::Type mRequest;
};
class WriteTestClusterBoolean : public WriteAttribute
{
public:
WriteTestClusterBoolean(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Boolean", credsIssuerConfig)
{
AddArgument("attr-name", "boolean");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterBoolean() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000000, mValue);
}
private:
bool mValue;
};
class WriteTestClusterBitmap8 : public WriteAttribute
{
public:
WriteTestClusterBitmap8(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap8", credsIssuerConfig)
{
AddArgument("attr-name", "bitmap8");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterBitmap8() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000001, mValue);
}
private:
uint8_t mValue;
};
class WriteTestClusterBitmap16 : public WriteAttribute
{
public:
WriteTestClusterBitmap16(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap16", credsIssuerConfig)
{
AddArgument("attr-name", "bitmap16");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterBitmap16() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000002, mValue);
}
private:
uint16_t mValue;
};
class WriteTestClusterBitmap32 : public WriteAttribute
{
public:
WriteTestClusterBitmap32(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap32", credsIssuerConfig)
{
AddArgument("attr-name", "bitmap32");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterBitmap32() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000003, mValue);
}
private:
uint32_t mValue;
};
class WriteTestClusterBitmap64 : public WriteAttribute
{
public:
WriteTestClusterBitmap64(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Bitmap64", credsIssuerConfig)
{
AddArgument("attr-name", "bitmap64");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterBitmap64() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000004, mValue);
}
private:
uint64_t mValue;
};
class WriteTestClusterInt8u : public WriteAttribute
{
public:
WriteTestClusterInt8u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int8u", credsIssuerConfig)
{
AddArgument("attr-name", "int8u");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt8u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000005, mValue);
}
private:
uint8_t mValue;
};
class WriteTestClusterInt16u : public WriteAttribute
{
public:
WriteTestClusterInt16u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int16u", credsIssuerConfig)
{
AddArgument("attr-name", "int16u");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt16u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000006, mValue);
}
private:
uint16_t mValue;
};
class WriteTestClusterInt24u : public WriteAttribute
{
public:
WriteTestClusterInt24u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int24u", credsIssuerConfig)
{
AddArgument("attr-name", "int24u");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt24u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000007, mValue);
}
private:
uint32_t mValue;
};
class WriteTestClusterInt32u : public WriteAttribute
{
public:
WriteTestClusterInt32u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int32u", credsIssuerConfig)
{
AddArgument("attr-name", "int32u");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt32u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000008, mValue);
}
private:
uint32_t mValue;
};
class WriteTestClusterInt40u : public WriteAttribute
{
public:
WriteTestClusterInt40u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int40u", credsIssuerConfig)
{
AddArgument("attr-name", "int40u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt40u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000009, mValue);
}
private:
uint64_t mValue;
};
class WriteTestClusterInt48u : public WriteAttribute
{
public:
WriteTestClusterInt48u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int48u", credsIssuerConfig)
{
AddArgument("attr-name", "int48u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt48u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000A, mValue);
}
private:
uint64_t mValue;
};
class WriteTestClusterInt56u : public WriteAttribute
{
public:
WriteTestClusterInt56u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int56u", credsIssuerConfig)
{
AddArgument("attr-name", "int56u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt56u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000B, mValue);
}
private:
uint64_t mValue;
};
class WriteTestClusterInt64u : public WriteAttribute
{
public:
WriteTestClusterInt64u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int64u", credsIssuerConfig)
{
AddArgument("attr-name", "int64u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt64u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000C, mValue);
}
private:
uint64_t mValue;
};
class WriteTestClusterInt8s : public WriteAttribute
{
public:
WriteTestClusterInt8s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int8s", credsIssuerConfig)
{
AddArgument("attr-name", "int8s");
AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt8s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000D, mValue);
}
private:
int8_t mValue;
};
class WriteTestClusterInt16s : public WriteAttribute
{
public:
WriteTestClusterInt16s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int16s", credsIssuerConfig)
{
AddArgument("attr-name", "int16s");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt16s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000E, mValue);
}
private:
int16_t mValue;
};
class WriteTestClusterInt24s : public WriteAttribute
{
public:
WriteTestClusterInt24s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int24s", credsIssuerConfig)
{
AddArgument("attr-name", "int24s");
AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt24s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000000F, mValue);
}
private:
int32_t mValue;
};
class WriteTestClusterInt32s : public WriteAttribute
{
public:
WriteTestClusterInt32s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int32s", credsIssuerConfig)
{
AddArgument("attr-name", "int32s");
AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt32s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000010, mValue);
}
private:
int32_t mValue;
};
class WriteTestClusterInt40s : public WriteAttribute
{
public:
WriteTestClusterInt40s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int40s", credsIssuerConfig)
{
AddArgument("attr-name", "int40s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt40s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000011, mValue);
}
private:
int64_t mValue;
};
class WriteTestClusterInt48s : public WriteAttribute
{
public:
WriteTestClusterInt48s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int48s", credsIssuerConfig)
{
AddArgument("attr-name", "int48s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt48s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000012, mValue);
}
private:
int64_t mValue;
};
class WriteTestClusterInt56s : public WriteAttribute
{
public:
WriteTestClusterInt56s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int56s", credsIssuerConfig)
{
AddArgument("attr-name", "int56s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt56s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000013, mValue);
}
private:
int64_t mValue;
};
class WriteTestClusterInt64s : public WriteAttribute
{
public:
WriteTestClusterInt64s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Int64s", credsIssuerConfig)
{
AddArgument("attr-name", "int64s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterInt64s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000014, mValue);
}
private:
int64_t mValue;
};
class WriteTestClusterEnum8 : public WriteAttribute
{
public:
WriteTestClusterEnum8(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Enum8", credsIssuerConfig)
{
AddArgument("attr-name", "enum8");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterEnum8() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000015, mValue);
}
private:
uint8_t mValue;
};
class WriteTestClusterEnum16 : public WriteAttribute
{
public:
WriteTestClusterEnum16(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Enum16", credsIssuerConfig)
{
AddArgument("attr-name", "enum16");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterEnum16() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000016, mValue);
}
private:
uint16_t mValue;
};
class WriteTestClusterFloatSingle : public WriteAttribute
{
public:
WriteTestClusterFloatSingle(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("FloatSingle", credsIssuerConfig)
{
AddArgument("attr-name", "float-single");
AddArgument("attr-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(), &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterFloatSingle() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000017, mValue);
}
private:
float mValue;
};
class WriteTestClusterFloatDouble : public WriteAttribute
{
public:
WriteTestClusterFloatDouble(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("FloatDouble", credsIssuerConfig)
{
AddArgument("attr-name", "float-double");
AddArgument("attr-value", -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterFloatDouble() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000018, mValue);
}
private:
double mValue;
};
class WriteTestClusterOctetString : public WriteAttribute
{
public:
WriteTestClusterOctetString(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("OctetString", credsIssuerConfig)
{
AddArgument("attr-name", "octet-string");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterOctetString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000019, mValue);
}
private:
chip::ByteSpan mValue;
};
class WriteTestClusterListInt8u : public WriteAttribute
{
public:
WriteTestClusterListInt8u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ListInt8u", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "list-int8u");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteTestClusterListInt8u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001A, mValue);
}
private:
chip::app::DataModel::List<const uint8_t> mValue;
TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex;
};
class WriteTestClusterListOctetString : public WriteAttribute
{
public:
WriteTestClusterListOctetString(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ListOctetString", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "list-octet-string");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteTestClusterListOctetString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001B, mValue);
}
private:
chip::app::DataModel::List<const chip::ByteSpan> mValue;
TypedComplexArgument<chip::app::DataModel::List<const chip::ByteSpan>> mComplex;
};
class WriteTestClusterListStructOctetString : public WriteAttribute
{
public:
WriteTestClusterListStructOctetString(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ListStructOctetString", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "list-struct-octet-string");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteTestClusterListStructOctetString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001C, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type> mValue;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::TestListStructOctet::Type>>
mComplex;
};
class WriteTestClusterLongOctetString : public WriteAttribute
{
public:
WriteTestClusterLongOctetString(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("LongOctetString", credsIssuerConfig)
{
AddArgument("attr-name", "long-octet-string");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterLongOctetString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001D, mValue);
}
private:
chip::ByteSpan mValue;
};
class WriteTestClusterCharString : public WriteAttribute
{
public:
WriteTestClusterCharString(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("CharString", credsIssuerConfig)
{
AddArgument("attr-name", "char-string");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterCharString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001E, mValue);
}
private:
chip::CharSpan mValue;
};
class WriteTestClusterLongCharString : public WriteAttribute
{
public:
WriteTestClusterLongCharString(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("LongCharString", credsIssuerConfig)
{
AddArgument("attr-name", "long-char-string");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterLongCharString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000001F, mValue);
}
private:
chip::CharSpan mValue;
};
class WriteTestClusterEpochUs : public WriteAttribute
{
public:
WriteTestClusterEpochUs(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("EpochUs", credsIssuerConfig)
{
AddArgument("attr-name", "epoch-us");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterEpochUs() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000020, mValue);
}
private:
uint64_t mValue;
};
class WriteTestClusterEpochS : public WriteAttribute
{
public:
WriteTestClusterEpochS(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("EpochS", credsIssuerConfig)
{
AddArgument("attr-name", "epoch-s");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterEpochS() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000021, mValue);
}
private:
uint32_t mValue;
};
class WriteTestClusterVendorId : public WriteAttribute
{
public:
WriteTestClusterVendorId(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("VendorId", credsIssuerConfig)
{
AddArgument("attr-name", "vendor-id");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterVendorId() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000022, mValue);
}
private:
chip::VendorId mValue;
};
class WriteTestClusterListNullablesAndOptionalsStruct : public WriteAttribute
{
public:
WriteTestClusterListNullablesAndOptionalsStruct(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ListNullablesAndOptionalsStruct", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "list-nullables-and-optionals-struct");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteTestClusterListNullablesAndOptionalsStruct() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000023, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::Type> mValue;
TypedComplexArgument<
chip::app::DataModel::List<const chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::Type>>
mComplex;
};
class WriteTestClusterEnumAttr : public WriteAttribute
{
public:
WriteTestClusterEnumAttr(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("EnumAttr", credsIssuerConfig)
{
AddArgument("attr-name", "enum-attr");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterEnumAttr() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000024, mValue);
}
private:
chip::app::Clusters::TestCluster::SimpleEnum mValue;
};
class WriteTestClusterStructAttr : public WriteAttribute
{
public:
WriteTestClusterStructAttr(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("StructAttr", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "struct-attr");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteTestClusterStructAttr() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000025, mValue);
}
private:
chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type mValue;
TypedComplexArgument<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mComplex;
};
class WriteTestClusterRangeRestrictedInt8u : public WriteAttribute
{
public:
WriteTestClusterRangeRestrictedInt8u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("RangeRestrictedInt8u", credsIssuerConfig)
{
AddArgument("attr-name", "range-restricted-int8u");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterRangeRestrictedInt8u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000026, mValue);
}
private:
uint8_t mValue;
};
class WriteTestClusterRangeRestrictedInt8s : public WriteAttribute
{
public:
WriteTestClusterRangeRestrictedInt8s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("RangeRestrictedInt8s", credsIssuerConfig)
{
AddArgument("attr-name", "range-restricted-int8s");
AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterRangeRestrictedInt8s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000027, mValue);
}
private:
int8_t mValue;
};
class WriteTestClusterRangeRestrictedInt16u : public WriteAttribute
{
public:
WriteTestClusterRangeRestrictedInt16u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("RangeRestrictedInt16u", credsIssuerConfig)
{
AddArgument("attr-name", "range-restricted-int16u");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterRangeRestrictedInt16u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000028, mValue);
}
private:
uint16_t mValue;
};
class WriteTestClusterRangeRestrictedInt16s : public WriteAttribute
{
public:
WriteTestClusterRangeRestrictedInt16s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("RangeRestrictedInt16s", credsIssuerConfig)
{
AddArgument("attr-name", "range-restricted-int16s");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterRangeRestrictedInt16s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000029, mValue);
}
private:
int16_t mValue;
};
class WriteTestClusterTimedWriteBoolean : public WriteAttribute
{
public:
WriteTestClusterTimedWriteBoolean(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("TimedWriteBoolean", credsIssuerConfig)
{
AddArgument("attr-name", "timed-write-boolean");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterTimedWriteBoolean() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000030, mValue);
}
private:
bool mValue;
};
class WriteTestClusterGeneralErrorBoolean : public WriteAttribute
{
public:
WriteTestClusterGeneralErrorBoolean(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("GeneralErrorBoolean", credsIssuerConfig)
{
AddArgument("attr-name", "general-error-boolean");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterGeneralErrorBoolean() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000031, mValue);
}
private:
bool mValue;
};
class WriteTestClusterClusterErrorBoolean : public WriteAttribute
{
public:
WriteTestClusterClusterErrorBoolean(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ClusterErrorBoolean", credsIssuerConfig)
{
AddArgument("attr-name", "cluster-error-boolean");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterClusterErrorBoolean() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00000032, mValue);
}
private:
bool mValue;
};
class WriteTestClusterUnsupported : public WriteAttribute
{
public:
WriteTestClusterUnsupported(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Unsupported", credsIssuerConfig)
{
AddArgument("attr-name", "unsupported");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterUnsupported() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x000000FF, mValue);
}
private:
bool mValue;
};
class WriteTestClusterNullableBoolean : public WriteAttribute
{
public:
WriteTestClusterNullableBoolean(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableBoolean", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-boolean");
AddArgument("attr-value", 0, 1, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableBoolean() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008000, mValue);
}
private:
chip::app::DataModel::Nullable<bool> mValue;
};
class WriteTestClusterNullableBitmap8 : public WriteAttribute
{
public:
WriteTestClusterNullableBitmap8(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableBitmap8", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-bitmap8");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableBitmap8() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008001, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
class WriteTestClusterNullableBitmap16 : public WriteAttribute
{
public:
WriteTestClusterNullableBitmap16(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableBitmap16", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-bitmap16");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableBitmap16() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008002, mValue);
}
private:
chip::app::DataModel::Nullable<uint16_t> mValue;
};
class WriteTestClusterNullableBitmap32 : public WriteAttribute
{
public:
WriteTestClusterNullableBitmap32(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableBitmap32", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-bitmap32");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableBitmap32() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008003, mValue);
}
private:
chip::app::DataModel::Nullable<uint32_t> mValue;
};
class WriteTestClusterNullableBitmap64 : public WriteAttribute
{
public:
WriteTestClusterNullableBitmap64(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableBitmap64", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-bitmap64");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableBitmap64() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008004, mValue);
}
private:
chip::app::DataModel::Nullable<uint64_t> mValue;
};
class WriteTestClusterNullableInt8u : public WriteAttribute
{
public:
WriteTestClusterNullableInt8u(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NullableInt8u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int8u");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt8u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008005, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
class WriteTestClusterNullableInt16u : public WriteAttribute
{
public:
WriteTestClusterNullableInt16u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt16u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int16u");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt16u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008006, mValue);
}
private:
chip::app::DataModel::Nullable<uint16_t> mValue;
};
class WriteTestClusterNullableInt24u : public WriteAttribute
{
public:
WriteTestClusterNullableInt24u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt24u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int24u");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt24u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008007, mValue);
}
private:
chip::app::DataModel::Nullable<uint32_t> mValue;
};
class WriteTestClusterNullableInt32u : public WriteAttribute
{
public:
WriteTestClusterNullableInt32u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt32u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int32u");
AddArgument("attr-value", 0, UINT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt32u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008008, mValue);
}
private:
chip::app::DataModel::Nullable<uint32_t> mValue;
};
class WriteTestClusterNullableInt40u : public WriteAttribute
{
public:
WriteTestClusterNullableInt40u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt40u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int40u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt40u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008009, mValue);
}
private:
chip::app::DataModel::Nullable<uint64_t> mValue;
};
class WriteTestClusterNullableInt48u : public WriteAttribute
{
public:
WriteTestClusterNullableInt48u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt48u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int48u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt48u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800A, mValue);
}
private:
chip::app::DataModel::Nullable<uint64_t> mValue;
};
class WriteTestClusterNullableInt56u : public WriteAttribute
{
public:
WriteTestClusterNullableInt56u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt56u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int56u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt56u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800B, mValue);
}
private:
chip::app::DataModel::Nullable<uint64_t> mValue;
};
class WriteTestClusterNullableInt64u : public WriteAttribute
{
public:
WriteTestClusterNullableInt64u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt64u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int64u");
AddArgument("attr-value", 0, UINT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt64u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800C, mValue);
}
private:
chip::app::DataModel::Nullable<uint64_t> mValue;
};
class WriteTestClusterNullableInt8s : public WriteAttribute
{
public:
WriteTestClusterNullableInt8s(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NullableInt8s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int8s");
AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt8s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800D, mValue);
}
private:
chip::app::DataModel::Nullable<int8_t> mValue;
};
class WriteTestClusterNullableInt16s : public WriteAttribute
{
public:
WriteTestClusterNullableInt16s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt16s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int16s");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt16s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800E, mValue);
}
private:
chip::app::DataModel::Nullable<int16_t> mValue;
};
class WriteTestClusterNullableInt24s : public WriteAttribute
{
public:
WriteTestClusterNullableInt24s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt24s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int24s");
AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt24s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000800F, mValue);
}
private:
chip::app::DataModel::Nullable<int32_t> mValue;
};
class WriteTestClusterNullableInt32s : public WriteAttribute
{
public:
WriteTestClusterNullableInt32s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt32s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int32s");
AddArgument("attr-value", INT32_MIN, INT32_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt32s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008010, mValue);
}
private:
chip::app::DataModel::Nullable<int32_t> mValue;
};
class WriteTestClusterNullableInt40s : public WriteAttribute
{
public:
WriteTestClusterNullableInt40s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt40s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int40s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt40s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008011, mValue);
}
private:
chip::app::DataModel::Nullable<int64_t> mValue;
};
class WriteTestClusterNullableInt48s : public WriteAttribute
{
public:
WriteTestClusterNullableInt48s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt48s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int48s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt48s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008012, mValue);
}
private:
chip::app::DataModel::Nullable<int64_t> mValue;
};
class WriteTestClusterNullableInt56s : public WriteAttribute
{
public:
WriteTestClusterNullableInt56s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt56s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int56s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt56s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008013, mValue);
}
private:
chip::app::DataModel::Nullable<int64_t> mValue;
};
class WriteTestClusterNullableInt64s : public WriteAttribute
{
public:
WriteTestClusterNullableInt64s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableInt64s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-int64s");
AddArgument("attr-value", INT64_MIN, INT64_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableInt64s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008014, mValue);
}
private:
chip::app::DataModel::Nullable<int64_t> mValue;
};
class WriteTestClusterNullableEnum8 : public WriteAttribute
{
public:
WriteTestClusterNullableEnum8(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("NullableEnum8", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-enum8");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableEnum8() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008015, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
class WriteTestClusterNullableEnum16 : public WriteAttribute
{
public:
WriteTestClusterNullableEnum16(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableEnum16", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-enum16");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableEnum16() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008016, mValue);
}
private:
chip::app::DataModel::Nullable<uint16_t> mValue;
};
class WriteTestClusterNullableFloatSingle : public WriteAttribute
{
public:
WriteTestClusterNullableFloatSingle(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableFloatSingle", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-float-single");
AddArgument("attr-value", -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity(), &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableFloatSingle() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008017, mValue);
}
private:
chip::app::DataModel::Nullable<float> mValue;
};
class WriteTestClusterNullableFloatDouble : public WriteAttribute
{
public:
WriteTestClusterNullableFloatDouble(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableFloatDouble", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-float-double");
AddArgument("attr-value", -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableFloatDouble() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008018, mValue);
}
private:
chip::app::DataModel::Nullable<double> mValue;
};
class WriteTestClusterNullableOctetString : public WriteAttribute
{
public:
WriteTestClusterNullableOctetString(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableOctetString", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-octet-string");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableOctetString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008019, mValue);
}
private:
chip::app::DataModel::Nullable<chip::ByteSpan> mValue;
};
class WriteTestClusterNullableCharString : public WriteAttribute
{
public:
WriteTestClusterNullableCharString(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableCharString", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-char-string");
AddArgument("attr-value", &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableCharString() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000801E, mValue);
}
private:
chip::app::DataModel::Nullable<chip::CharSpan> mValue;
};
class WriteTestClusterNullableEnumAttr : public WriteAttribute
{
public:
WriteTestClusterNullableEnumAttr(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableEnumAttr", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-enum-attr");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableEnumAttr() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008024, mValue);
}
private:
chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::SimpleEnum> mValue;
};
class WriteTestClusterNullableStruct : public WriteAttribute
{
public:
WriteTestClusterNullableStruct(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableStruct", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "nullable-struct");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableStruct() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008025, mValue);
}
private:
chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type> mValue;
TypedComplexArgument<chip::app::DataModel::Nullable<chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type>> mComplex;
};
class WriteTestClusterNullableRangeRestrictedInt8u : public WriteAttribute
{
public:
WriteTestClusterNullableRangeRestrictedInt8u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableRangeRestrictedInt8u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-range-restricted-int8u");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableRangeRestrictedInt8u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008026, mValue);
}
private:
chip::app::DataModel::Nullable<uint8_t> mValue;
};
class WriteTestClusterNullableRangeRestrictedInt8s : public WriteAttribute
{
public:
WriteTestClusterNullableRangeRestrictedInt8s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableRangeRestrictedInt8s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-range-restricted-int8s");
AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableRangeRestrictedInt8s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008027, mValue);
}
private:
chip::app::DataModel::Nullable<int8_t> mValue;
};
class WriteTestClusterNullableRangeRestrictedInt16u : public WriteAttribute
{
public:
WriteTestClusterNullableRangeRestrictedInt16u(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableRangeRestrictedInt16u", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-range-restricted-int16u");
AddArgument("attr-value", 0, UINT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableRangeRestrictedInt16u() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008028, mValue);
}
private:
chip::app::DataModel::Nullable<uint16_t> mValue;
};
class WriteTestClusterNullableRangeRestrictedInt16s : public WriteAttribute
{
public:
WriteTestClusterNullableRangeRestrictedInt16s(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("NullableRangeRestrictedInt16s", credsIssuerConfig)
{
AddArgument("attr-name", "nullable-range-restricted-int16s");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTestClusterNullableRangeRestrictedInt16s() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x00008029, mValue);
}
private:
chip::app::DataModel::Nullable<int16_t> mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster Thermostat | 0x0201 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ClearWeeklySchedule | 0x03 |
| * GetRelayStatusLog | 0x04 |
| * GetWeeklySchedule | 0x02 |
| * SetWeeklySchedule | 0x01 |
| * SetpointRaiseLower | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * LocalTemperature | 0x0000 |
| * AbsMinHeatSetpointLimit | 0x0003 |
| * AbsMaxHeatSetpointLimit | 0x0004 |
| * AbsMinCoolSetpointLimit | 0x0005 |
| * AbsMaxCoolSetpointLimit | 0x0006 |
| * OccupiedCoolingSetpoint | 0x0011 |
| * OccupiedHeatingSetpoint | 0x0012 |
| * MinHeatSetpointLimit | 0x0015 |
| * MaxHeatSetpointLimit | 0x0016 |
| * MinCoolSetpointLimit | 0x0017 |
| * MaxCoolSetpointLimit | 0x0018 |
| * MinSetpointDeadBand | 0x0019 |
| * ControlSequenceOfOperation | 0x001B |
| * SystemMode | 0x001C |
| * StartOfWeek | 0x0020 |
| * NumberOfWeeklyTransitions | 0x0021 |
| * NumberOfDailyTransitions | 0x0022 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command ClearWeeklySchedule
*/
class ThermostatClearWeeklySchedule : public ClusterCommand
{
public:
ThermostatClearWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("clear-weekly-schedule", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000003) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000003, mRequest);
}
private:
chip::app::Clusters::Thermostat::Commands::ClearWeeklySchedule::Type mRequest;
};
/*
* Command GetRelayStatusLog
*/
class ThermostatGetRelayStatusLog : public ClusterCommand
{
public:
ThermostatGetRelayStatusLog(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-relay-status-log", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000004, mRequest);
}
private:
chip::app::Clusters::Thermostat::Commands::GetRelayStatusLog::Type mRequest;
};
/*
* Command GetWeeklySchedule
*/
class ThermostatGetWeeklySchedule : public ClusterCommand
{
public:
ThermostatGetWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("get-weekly-schedule", credsIssuerConfig)
{
AddArgument("DaysToReturn", 0, UINT8_MAX, &mRequest.daysToReturn);
AddArgument("ModeToReturn", 0, UINT8_MAX, &mRequest.modeToReturn);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000002, mRequest);
}
private:
chip::app::Clusters::Thermostat::Commands::GetWeeklySchedule::Type mRequest;
};
/*
* Command SetWeeklySchedule
*/
class ThermostatSetWeeklySchedule : public ClusterCommand
{
public:
ThermostatSetWeeklySchedule(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("set-weekly-schedule", credsIssuerConfig), mComplex_Payload(&mRequest.payload)
{
AddArgument("NumberOfTransitionsForSequence", 0, UINT8_MAX, &mRequest.numberOfTransitionsForSequence);
AddArgument("DayOfWeekForSequence", 0, UINT8_MAX, &mRequest.dayOfWeekForSequence);
AddArgument("ModeForSequence", 0, UINT8_MAX, &mRequest.modeForSequence);
AddArgument("Payload", &mComplex_Payload);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000001, mRequest);
}
private:
chip::app::Clusters::Thermostat::Commands::SetWeeklySchedule::Type mRequest;
TypedComplexArgument<chip::app::DataModel::List<const uint8_t>> mComplex_Payload;
};
/*
* Command SetpointRaiseLower
*/
class ThermostatSetpointRaiseLower : public ClusterCommand
{
public:
ThermostatSetpointRaiseLower(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("setpoint-raise-lower", credsIssuerConfig)
{
AddArgument("Mode", 0, UINT8_MAX, &mRequest.mode);
AddArgument("Amount", INT8_MIN, INT8_MAX, &mRequest.amount);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000201) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000201, 0x00000000, mRequest);
}
private:
chip::app::Clusters::Thermostat::Commands::SetpointRaiseLower::Type mRequest;
};
class WriteThermostatOccupiedCoolingSetpoint : public WriteAttribute
{
public:
WriteThermostatOccupiedCoolingSetpoint(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OccupiedCoolingSetpoint", credsIssuerConfig)
{
AddArgument("attr-name", "occupied-cooling-setpoint");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatOccupiedCoolingSetpoint() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000011, mValue);
}
private:
int16_t mValue;
};
class WriteThermostatOccupiedHeatingSetpoint : public WriteAttribute
{
public:
WriteThermostatOccupiedHeatingSetpoint(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("OccupiedHeatingSetpoint", credsIssuerConfig)
{
AddArgument("attr-name", "occupied-heating-setpoint");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatOccupiedHeatingSetpoint() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000012, mValue);
}
private:
int16_t mValue;
};
class WriteThermostatMinHeatSetpointLimit : public WriteAttribute
{
public:
WriteThermostatMinHeatSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("MinHeatSetpointLimit", credsIssuerConfig)
{
AddArgument("attr-name", "min-heat-setpoint-limit");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatMinHeatSetpointLimit() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000015, mValue);
}
private:
int16_t mValue;
};
class WriteThermostatMaxHeatSetpointLimit : public WriteAttribute
{
public:
WriteThermostatMaxHeatSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("MaxHeatSetpointLimit", credsIssuerConfig)
{
AddArgument("attr-name", "max-heat-setpoint-limit");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatMaxHeatSetpointLimit() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000016, mValue);
}
private:
int16_t mValue;
};
class WriteThermostatMinCoolSetpointLimit : public WriteAttribute
{
public:
WriteThermostatMinCoolSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("MinCoolSetpointLimit", credsIssuerConfig)
{
AddArgument("attr-name", "min-cool-setpoint-limit");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatMinCoolSetpointLimit() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000017, mValue);
}
private:
int16_t mValue;
};
class WriteThermostatMaxCoolSetpointLimit : public WriteAttribute
{
public:
WriteThermostatMaxCoolSetpointLimit(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("MaxCoolSetpointLimit", credsIssuerConfig)
{
AddArgument("attr-name", "max-cool-setpoint-limit");
AddArgument("attr-value", INT16_MIN, INT16_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatMaxCoolSetpointLimit() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000018, mValue);
}
private:
int16_t mValue;
};
class WriteThermostatMinSetpointDeadBand : public WriteAttribute
{
public:
WriteThermostatMinSetpointDeadBand(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("MinSetpointDeadBand", credsIssuerConfig)
{
AddArgument("attr-name", "min-setpoint-dead-band");
AddArgument("attr-value", INT8_MIN, INT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatMinSetpointDeadBand() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x00000019, mValue);
}
private:
int8_t mValue;
};
class WriteThermostatControlSequenceOfOperation : public WriteAttribute
{
public:
WriteThermostatControlSequenceOfOperation(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ControlSequenceOfOperation", credsIssuerConfig)
{
AddArgument("attr-name", "control-sequence-of-operation");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatControlSequenceOfOperation() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x0000001B, mValue);
}
private:
uint8_t mValue;
};
class WriteThermostatSystemMode : public WriteAttribute
{
public:
WriteThermostatSystemMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("SystemMode", credsIssuerConfig)
{
AddArgument("attr-name", "system-mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatSystemMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000201, 0x0000001C, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster ThermostatUserInterfaceConfiguration | 0x0204 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * TemperatureDisplayMode | 0x0000 |
| * KeypadLockout | 0x0001 |
| * ScheduleProgrammingVisibility | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode : public WriteAttribute
{
public:
WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("TemperatureDisplayMode", credsIssuerConfig)
{
AddArgument("attr-name", "temperature-display-mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000204, 0x00000000, mValue);
}
private:
uint8_t mValue;
};
class WriteThermostatUserInterfaceConfigurationKeypadLockout : public WriteAttribute
{
public:
WriteThermostatUserInterfaceConfigurationKeypadLockout(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("KeypadLockout", credsIssuerConfig)
{
AddArgument("attr-name", "keypad-lockout");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatUserInterfaceConfigurationKeypadLockout() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000204, 0x00000001, mValue);
}
private:
uint8_t mValue;
};
class WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility : public WriteAttribute
{
public:
WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ScheduleProgrammingVisibility", credsIssuerConfig)
{
AddArgument("attr-name", "schedule-programming-visibility");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000204, 0x00000002, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster ThreadNetworkDiagnostics | 0x0035 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ResetCounts | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Channel | 0x0000 |
| * RoutingRole | 0x0001 |
| * NetworkName | 0x0002 |
| * PanId | 0x0003 |
| * ExtendedPanId | 0x0004 |
| * MeshLocalPrefix | 0x0005 |
| * OverrunCount | 0x0006 |
| * NeighborTableList | 0x0007 |
| * RouteTableList | 0x0008 |
| * PartitionId | 0x0009 |
| * Weighting | 0x000A |
| * DataVersion | 0x000B |
| * StableDataVersion | 0x000C |
| * LeaderRouterId | 0x000D |
| * DetachedRoleCount | 0x000E |
| * ChildRoleCount | 0x000F |
| * RouterRoleCount | 0x0010 |
| * LeaderRoleCount | 0x0011 |
| * AttachAttemptCount | 0x0012 |
| * PartitionIdChangeCount | 0x0013 |
| * BetterPartitionAttachAttemptCount | 0x0014 |
| * ParentChangeCount | 0x0015 |
| * TxTotalCount | 0x0016 |
| * TxUnicastCount | 0x0017 |
| * TxBroadcastCount | 0x0018 |
| * TxAckRequestedCount | 0x0019 |
| * TxAckedCount | 0x001A |
| * TxNoAckRequestedCount | 0x001B |
| * TxDataCount | 0x001C |
| * TxDataPollCount | 0x001D |
| * TxBeaconCount | 0x001E |
| * TxBeaconRequestCount | 0x001F |
| * TxOtherCount | 0x0020 |
| * TxRetryCount | 0x0021 |
| * TxDirectMaxRetryExpiryCount | 0x0022 |
| * TxIndirectMaxRetryExpiryCount | 0x0023 |
| * TxErrCcaCount | 0x0024 |
| * TxErrAbortCount | 0x0025 |
| * TxErrBusyChannelCount | 0x0026 |
| * RxTotalCount | 0x0027 |
| * RxUnicastCount | 0x0028 |
| * RxBroadcastCount | 0x0029 |
| * RxDataCount | 0x002A |
| * RxDataPollCount | 0x002B |
| * RxBeaconCount | 0x002C |
| * RxBeaconRequestCount | 0x002D |
| * RxOtherCount | 0x002E |
| * RxAddressFilteredCount | 0x002F |
| * RxDestAddrFilteredCount | 0x0030 |
| * RxDuplicatedCount | 0x0031 |
| * RxErrNoFrameCount | 0x0032 |
| * RxErrUnknownNeighborCount | 0x0033 |
| * RxErrInvalidSrcAddrCount | 0x0034 |
| * RxErrSecCount | 0x0035 |
| * RxErrFcsCount | 0x0036 |
| * RxErrOtherCount | 0x0037 |
| * ActiveTimestamp | 0x0038 |
| * PendingTimestamp | 0x0039 |
| * Delay | 0x003A |
| * SecurityPolicy | 0x003B |
| * ChannelMask | 0x003C |
| * OperationalDatasetComponents | 0x003D |
| * ActiveNetworkFaultsList | 0x003E |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * ConnectionStatus | 0x0000 |
\*----------------------------------------------------------------------------*/
/*
* Command ResetCounts
*/
class ThreadNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
ThreadNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("reset-counts", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000035) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000035, 0x00000000, mRequest);
}
private:
chip::app::Clusters::ThreadNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster TimeFormatLocalization | 0x002C |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * HourFormat | 0x0000 |
| * ActiveCalendarType | 0x0001 |
| * SupportedCalendarTypes | 0x0002 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteTimeFormatLocalizationHourFormat : public WriteAttribute
{
public:
WriteTimeFormatLocalizationHourFormat(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("HourFormat", credsIssuerConfig)
{
AddArgument("attr-name", "hour-format");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTimeFormatLocalizationHourFormat() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000002C, 0x00000000, mValue);
}
private:
chip::app::Clusters::TimeFormatLocalization::HourFormat mValue;
};
class WriteTimeFormatLocalizationActiveCalendarType : public WriteAttribute
{
public:
WriteTimeFormatLocalizationActiveCalendarType(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("ActiveCalendarType", credsIssuerConfig)
{
AddArgument("attr-name", "active-calendar-type");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteTimeFormatLocalizationActiveCalendarType() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000002C, 0x00000001, mValue);
}
private:
chip::app::Clusters::TimeFormatLocalization::CalendarType mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster UnitLocalization | 0x002D |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * TemperatureUnit | 0x0000 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteUnitLocalizationTemperatureUnit : public WriteAttribute
{
public:
WriteUnitLocalizationTemperatureUnit(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("TemperatureUnit", credsIssuerConfig)
{
AddArgument("attr-name", "temperature-unit");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteUnitLocalizationTemperatureUnit() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x0000002D, 0x00000000, mValue);
}
private:
chip::app::Clusters::UnitLocalization::TempUnit mValue;
};
/*----------------------------------------------------------------------------*\
| Cluster UserLabel | 0x0041 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * LabelList | 0x0000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
class WriteUserLabelLabelList : public WriteAttribute
{
public:
WriteUserLabelLabelList(CredentialIssuerCommands * credsIssuerConfig) :
WriteAttribute("LabelList", credsIssuerConfig), mComplex(&mValue)
{
AddArgument("attr-name", "label-list");
AddArgument("attr-value", &mComplex);
WriteAttribute::AddArguments();
}
~WriteUserLabelLabelList() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000041, 0x00000000, mValue);
}
private:
chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type> mValue;
TypedComplexArgument<chip::app::DataModel::List<const chip::app::Clusters::UserLabel::Structs::LabelStruct::Type>> mComplex;
};
/*----------------------------------------------------------------------------*\
| Cluster WakeOnLan | 0x0503 |
|------------------------------------------------------------------------------|
| Commands: | |
|------------------------------------------------------------------------------|
| Attributes: | |
| * WakeOnLanMacAddress | 0x0000 |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*\
| Cluster WiFiNetworkDiagnostics | 0x0036 |
|------------------------------------------------------------------------------|
| Commands: | |
| * ResetCounts | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Bssid | 0x0000 |
| * SecurityType | 0x0001 |
| * WiFiVersion | 0x0002 |
| * ChannelNumber | 0x0003 |
| * Rssi | 0x0004 |
| * BeaconLostCount | 0x0005 |
| * BeaconRxCount | 0x0006 |
| * PacketMulticastRxCount | 0x0007 |
| * PacketMulticastTxCount | 0x0008 |
| * PacketUnicastRxCount | 0x0009 |
| * PacketUnicastTxCount | 0x000A |
| * CurrentMaxRate | 0x000B |
| * OverrunCount | 0x000C |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
| * Disconnection | 0x0000 |
| * AssociationFailure | 0x0001 |
| * ConnectionStatus | 0x0002 |
\*----------------------------------------------------------------------------*/
/*
* Command ResetCounts
*/
class WiFiNetworkDiagnosticsResetCounts : public ClusterCommand
{
public:
WiFiNetworkDiagnosticsResetCounts(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("reset-counts", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000036) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000036, 0x00000000, mRequest);
}
private:
chip::app::Clusters::WiFiNetworkDiagnostics::Commands::ResetCounts::Type mRequest;
};
/*----------------------------------------------------------------------------*\
| Cluster WindowCovering | 0x0102 |
|------------------------------------------------------------------------------|
| Commands: | |
| * DownOrClose | 0x01 |
| * GoToLiftPercentage | 0x05 |
| * GoToLiftValue | 0x04 |
| * GoToTiltPercentage | 0x08 |
| * GoToTiltValue | 0x07 |
| * StopMotion | 0x02 |
| * UpOrOpen | 0x00 |
|------------------------------------------------------------------------------|
| Attributes: | |
| * Type | 0x0000 |
| * CurrentPositionLift | 0x0003 |
| * CurrentPositionTilt | 0x0004 |
| * ConfigStatus | 0x0007 |
| * CurrentPositionLiftPercentage | 0x0008 |
| * CurrentPositionTiltPercentage | 0x0009 |
| * OperationalStatus | 0x000A |
| * TargetPositionLiftPercent100ths | 0x000B |
| * TargetPositionTiltPercent100ths | 0x000C |
| * EndProductType | 0x000D |
| * CurrentPositionLiftPercent100ths | 0x000E |
| * CurrentPositionTiltPercent100ths | 0x000F |
| * InstalledOpenLimitLift | 0x0010 |
| * InstalledClosedLimitLift | 0x0011 |
| * InstalledOpenLimitTilt | 0x0012 |
| * InstalledClosedLimitTilt | 0x0013 |
| * Mode | 0x0017 |
| * SafetyStatus | 0x001A |
| * ServerGeneratedCommandList | 0xFFF8 |
| * ClientGeneratedCommandList | 0xFFF9 |
| * AttributeList | 0xFFFB |
| * FeatureMap | 0xFFFC |
| * ClusterRevision | 0xFFFD |
|------------------------------------------------------------------------------|
| Events: | |
\*----------------------------------------------------------------------------*/
/*
* Command DownOrClose
*/
class WindowCoveringDownOrClose : public ClusterCommand
{
public:
WindowCoveringDownOrClose(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("down-or-close", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000001) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000001, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::DownOrClose::Type mRequest;
};
/*
* Command GoToLiftPercentage
*/
class WindowCoveringGoToLiftPercentage : public ClusterCommand
{
public:
WindowCoveringGoToLiftPercentage(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("go-to-lift-percentage", credsIssuerConfig)
{
AddArgument("LiftPercentageValue", 0, UINT8_MAX, &mRequest.liftPercentageValue);
AddArgument("LiftPercent100thsValue", 0, UINT16_MAX, &mRequest.liftPercent100thsValue);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000005) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000005, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::GoToLiftPercentage::Type mRequest;
};
/*
* Command GoToLiftValue
*/
class WindowCoveringGoToLiftValue : public ClusterCommand
{
public:
WindowCoveringGoToLiftValue(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("go-to-lift-value", credsIssuerConfig)
{
AddArgument("LiftValue", 0, UINT16_MAX, &mRequest.liftValue);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000004) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000004, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::GoToLiftValue::Type mRequest;
};
/*
* Command GoToTiltPercentage
*/
class WindowCoveringGoToTiltPercentage : public ClusterCommand
{
public:
WindowCoveringGoToTiltPercentage(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("go-to-tilt-percentage", credsIssuerConfig)
{
AddArgument("TiltPercentageValue", 0, UINT8_MAX, &mRequest.tiltPercentageValue);
AddArgument("TiltPercent100thsValue", 0, UINT16_MAX, &mRequest.tiltPercent100thsValue);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000008) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000008, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::GoToTiltPercentage::Type mRequest;
};
/*
* Command GoToTiltValue
*/
class WindowCoveringGoToTiltValue : public ClusterCommand
{
public:
WindowCoveringGoToTiltValue(CredentialIssuerCommands * credsIssuerConfig) :
ClusterCommand("go-to-tilt-value", credsIssuerConfig)
{
AddArgument("TiltValue", 0, UINT16_MAX, &mRequest.tiltValue);
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000007) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000007, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::GoToTiltValue::Type mRequest;
};
/*
* Command StopMotion
*/
class WindowCoveringStopMotion : public ClusterCommand
{
public:
WindowCoveringStopMotion(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("stop-motion", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000002) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000002, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::StopMotion::Type mRequest;
};
/*
* Command UpOrOpen
*/
class WindowCoveringUpOrOpen : public ClusterCommand
{
public:
WindowCoveringUpOrOpen(CredentialIssuerCommands * credsIssuerConfig) : ClusterCommand("up-or-open", credsIssuerConfig)
{
ClusterCommand::AddArguments();
}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
ChipLogProgress(chipTool, "Sending cluster (0x00000102) command (0x00000000) on endpoint %" PRIu16, endpointId);
return ClusterCommand::SendCommand(device, endpointId, 0x00000102, 0x00000000, mRequest);
}
private:
chip::app::Clusters::WindowCovering::Commands::UpOrOpen::Type mRequest;
};
class WriteWindowCoveringMode : public WriteAttribute
{
public:
WriteWindowCoveringMode(CredentialIssuerCommands * credsIssuerConfig) : WriteAttribute("Mode", credsIssuerConfig)
{
AddArgument("attr-name", "mode");
AddArgument("attr-value", 0, UINT8_MAX, &mValue);
WriteAttribute::AddArguments();
}
~WriteWindowCoveringMode() {}
CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override
{
return WriteAttribute::SendCommand(device, endpointId, 0x00000102, 0x00000017, mValue);
}
private:
uint8_t mValue;
};
/*----------------------------------------------------------------------------*\
| Register all Clusters commands |
\*----------------------------------------------------------------------------*/
void registerClusterAccessControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::AccessControl;
const char * clusterName = "AccessControl";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "acl", Attributes::Acl::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "extension", Attributes::Extension::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteAccessControlAcl>(credsIssuerConfig), //
make_unique<WriteAccessControlExtension>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "acl", Attributes::Acl::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "extension", Attributes::Extension::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "access-control-entry-changed", Events::AccessControlEntryChanged::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "access-control-extension-changed", Events::AccessControlExtensionChanged::Id,
credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "access-control-entry-changed", Events::AccessControlEntryChanged::Id,
credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "access-control-extension-changed", Events::AccessControlExtensionChanged::Id,
credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterAccountLogin(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::AccountLogin;
const char * clusterName = "AccountLogin";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<AccountLoginGetSetupPINRequest>(credsIssuerConfig), //
make_unique<AccountLoginLoginRequest>(credsIssuerConfig), //
make_unique<AccountLoginLogoutRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterAdministratorCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::AdministratorCommissioning;
const char * clusterName = "AdministratorCommissioning";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<AdministratorCommissioningOpenBasicCommissioningWindow>(credsIssuerConfig), //
make_unique<AdministratorCommissioningOpenCommissioningWindow>(credsIssuerConfig), //
make_unique<AdministratorCommissioningRevokeCommissioning>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "window-status", Attributes::WindowStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "admin-fabric-index", Attributes::AdminFabricIndex::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "admin-vendor-id", Attributes::AdminVendorId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "window-status", Attributes::WindowStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "admin-fabric-index", Attributes::AdminFabricIndex::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "admin-vendor-id", Attributes::AdminVendorId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterApplicationBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ApplicationBasic;
const char * clusterName = "ApplicationBasic";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "application-name", Attributes::ApplicationName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-id", Attributes::ProductId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "application-app", Attributes::ApplicationApp::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "application-status", Attributes::ApplicationStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "application-version", Attributes::ApplicationVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "application-name", Attributes::ApplicationName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-id", Attributes::ProductId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "application-app", Attributes::ApplicationApp::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "application-status", Attributes::ApplicationStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "application-version", Attributes::ApplicationVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "allowed-vendor-list", Attributes::AllowedVendorList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterApplicationLauncher(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ApplicationLauncher;
const char * clusterName = "ApplicationLauncher";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ApplicationLauncherHideAppRequest>(credsIssuerConfig), //
make_unique<ApplicationLauncherLaunchAppRequest>(credsIssuerConfig), //
make_unique<ApplicationLauncherStopAppRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "application-launcher-list", Attributes::ApplicationLauncherList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "application-launcher-app", Attributes::ApplicationLauncherApp::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteApplicationLauncherApplicationLauncherApp>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "application-launcher-list", Attributes::ApplicationLauncherList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "application-launcher-app", Attributes::ApplicationLauncherApp::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterAudioOutput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::AudioOutput;
const char * clusterName = "AudioOutput";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<AudioOutputRenameOutputRequest>(credsIssuerConfig), //
make_unique<AudioOutputSelectOutputRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "audio-output-list", Attributes::AudioOutputList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-audio-output", Attributes::CurrentAudioOutput::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "audio-output-list", Attributes::AudioOutputList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-audio-output", Attributes::CurrentAudioOutput::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBarrierControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::BarrierControl;
const char * clusterName = "BarrierControl";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<BarrierControlBarrierControlGoToPercent>(credsIssuerConfig), //
make_unique<BarrierControlBarrierControlStop>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "barrier-moving-state", Attributes::BarrierMovingState::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "barrier-safety-status", Attributes::BarrierSafetyStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "barrier-capabilities", Attributes::BarrierCapabilities::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "barrier-position", Attributes::BarrierPosition::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "barrier-moving-state", Attributes::BarrierMovingState::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "barrier-safety-status", Attributes::BarrierSafetyStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "barrier-capabilities", Attributes::BarrierCapabilities::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "barrier-position", Attributes::BarrierPosition::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Basic;
const char * clusterName = "Basic";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "data-model-revision", Attributes::DataModelRevision::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "location", Attributes::Location::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "local-config-disabled", Attributes::LocalConfigDisabled::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteBasicNodeLabel>(credsIssuerConfig), //
make_unique<WriteBasicLocation>(credsIssuerConfig), //
make_unique<WriteBasicLocalConfigDisabled>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "data-model-revision", Attributes::DataModelRevision::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-id", Attributes::ProductID::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "location", Attributes::Location::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "local-config-disabled", Attributes::LocalConfigDisabled::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "unique-id", Attributes::UniqueID::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBinaryInputBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::BinaryInputBasic;
const char * clusterName = "BinaryInputBasic";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "out-of-service", Attributes::OutOfService::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "present-value", Attributes::PresentValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "status-flags", Attributes::StatusFlags::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteBinaryInputBasicOutOfService>(credsIssuerConfig), //
make_unique<WriteBinaryInputBasicPresentValue>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "out-of-service", Attributes::OutOfService::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "present-value", Attributes::PresentValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "status-flags", Attributes::StatusFlags::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBinding(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Binding;
const char * clusterName = "Binding";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<BindingBind>(credsIssuerConfig), //
make_unique<BindingUnbind>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBooleanState(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::BooleanState;
const char * clusterName = "BooleanState";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "state-value", Attributes::StateValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "state-value", Attributes::StateValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "state-change", Events::StateChange::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "state-change", Events::StateChange::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBridgedActions(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::BridgedActions;
const char * clusterName = "BridgedActions";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<BridgedActionsDisableAction>(credsIssuerConfig), //
make_unique<BridgedActionsDisableActionWithDuration>(credsIssuerConfig), //
make_unique<BridgedActionsEnableAction>(credsIssuerConfig), //
make_unique<BridgedActionsEnableActionWithDuration>(credsIssuerConfig), //
make_unique<BridgedActionsInstantAction>(credsIssuerConfig), //
make_unique<BridgedActionsInstantActionWithTransition>(credsIssuerConfig), //
make_unique<BridgedActionsPauseAction>(credsIssuerConfig), //
make_unique<BridgedActionsPauseActionWithDuration>(credsIssuerConfig), //
make_unique<BridgedActionsResumeAction>(credsIssuerConfig), //
make_unique<BridgedActionsStartAction>(credsIssuerConfig), //
make_unique<BridgedActionsStartActionWithDuration>(credsIssuerConfig), //
make_unique<BridgedActionsStopAction>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "action-list", Attributes::ActionList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "endpoint-list", Attributes::EndpointList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "setup-url", Attributes::SetupUrl::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "action-list", Attributes::ActionList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "endpoint-list", Attributes::EndpointList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "setup-url", Attributes::SetupUrl::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "action-failed", Events::ActionFailed::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "state-changed", Events::StateChanged::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "action-failed", Events::ActionFailed::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterBridgedDeviceBasic(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::BridgedDeviceBasic;
const char * clusterName = "BridgedDeviceBasic";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteBridgedDeviceBasicNodeLabel>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-name", Attributes::VendorName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorID::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-name", Attributes::ProductName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "node-label", Attributes::NodeLabel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "hardware-version", Attributes::HardwareVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "hardware-version-string", Attributes::HardwareVersionString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "software-version", Attributes::SoftwareVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "software-version-string", Attributes::SoftwareVersionString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "manufacturing-date", Attributes::ManufacturingDate::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "part-number", Attributes::PartNumber::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-url", Attributes::ProductURL::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "product-label", Attributes::ProductLabel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "serial-number", Attributes::SerialNumber::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "reachable", Attributes::Reachable::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "start-up", Events::StartUp::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "shut-down", Events::ShutDown::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "leave", Events::Leave::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "reachable-changed", Events::ReachableChanged::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterChannel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Channel;
const char * clusterName = "Channel";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ChannelChangeChannelByNumberRequest>(credsIssuerConfig), //
make_unique<ChannelChangeChannelRequest>(credsIssuerConfig), //
make_unique<ChannelSkipChannelRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "channel-list", Attributes::ChannelList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "channel-lineup", Attributes::ChannelLineup::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-channel", Attributes::CurrentChannel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteChannelChannelLineup>(credsIssuerConfig), //
make_unique<WriteChannelCurrentChannel>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "channel-list", Attributes::ChannelList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "channel-lineup", Attributes::ChannelLineup::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-channel", Attributes::CurrentChannel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterColorControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ColorControl;
const char * clusterName = "ColorControl";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ColorControlColorLoopSet>(credsIssuerConfig), //
make_unique<ColorControlEnhancedMoveHue>(credsIssuerConfig), //
make_unique<ColorControlEnhancedMoveToHue>(credsIssuerConfig), //
make_unique<ColorControlEnhancedMoveToHueAndSaturation>(credsIssuerConfig), //
make_unique<ColorControlEnhancedStepHue>(credsIssuerConfig), //
make_unique<ColorControlMoveColor>(credsIssuerConfig), //
make_unique<ColorControlMoveColorTemperature>(credsIssuerConfig), //
make_unique<ColorControlMoveHue>(credsIssuerConfig), //
make_unique<ColorControlMoveSaturation>(credsIssuerConfig), //
make_unique<ColorControlMoveToColor>(credsIssuerConfig), //
make_unique<ColorControlMoveToColorTemperature>(credsIssuerConfig), //
make_unique<ColorControlMoveToHue>(credsIssuerConfig), //
make_unique<ColorControlMoveToHueAndSaturation>(credsIssuerConfig), //
make_unique<ColorControlMoveToSaturation>(credsIssuerConfig), //
make_unique<ColorControlStepColor>(credsIssuerConfig), //
make_unique<ColorControlStepColorTemperature>(credsIssuerConfig), //
make_unique<ColorControlStepHue>(credsIssuerConfig), //
make_unique<ColorControlStepSaturation>(credsIssuerConfig), //
make_unique<ColorControlStopMoveStep>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-hue", Attributes::CurrentHue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-saturation", Attributes::CurrentSaturation::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-x", Attributes::CurrentX::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-y", Attributes::CurrentY::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "drift-compensation", Attributes::DriftCompensation::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "compensation-text", Attributes::CompensationText::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-temperature", Attributes::ColorTemperature::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-mode", Attributes::ColorMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-control-options", Attributes::ColorControlOptions::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-primaries", Attributes::NumberOfPrimaries::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary1x", Attributes::Primary1X::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary1y", Attributes::Primary1Y::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary1intensity", Attributes::Primary1Intensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary2x", Attributes::Primary2X::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary2y", Attributes::Primary2Y::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary2intensity", Attributes::Primary2Intensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary3x", Attributes::Primary3X::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary3y", Attributes::Primary3Y::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary3intensity", Attributes::Primary3Intensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary4x", Attributes::Primary4X::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary4y", Attributes::Primary4Y::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary4intensity", Attributes::Primary4Intensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary5x", Attributes::Primary5X::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary5y", Attributes::Primary5Y::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary5intensity", Attributes::Primary5Intensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary6x", Attributes::Primary6X::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary6y", Attributes::Primary6Y::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "primary6intensity", Attributes::Primary6Intensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "white-point-x", Attributes::WhitePointX::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "white-point-y", Attributes::WhitePointY::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-rx", Attributes::ColorPointRX::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-ry", Attributes::ColorPointRY::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-rintensity", Attributes::ColorPointRIntensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-gx", Attributes::ColorPointGX::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-gy", Attributes::ColorPointGY::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-gintensity", Attributes::ColorPointGIntensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-bx", Attributes::ColorPointBX::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-by", Attributes::ColorPointBY::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-point-bintensity", Attributes::ColorPointBIntensity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enhanced-current-hue", Attributes::EnhancedCurrentHue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enhanced-color-mode", Attributes::EnhancedColorMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-loop-active", Attributes::ColorLoopActive::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-loop-direction", Attributes::ColorLoopDirection::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-loop-time", Attributes::ColorLoopTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-loop-start-enhanced-hue", Attributes::ColorLoopStartEnhancedHue::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-loop-stored-enhanced-hue", Attributes::ColorLoopStoredEnhancedHue::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-capabilities", Attributes::ColorCapabilities::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-temp-physical-min", Attributes::ColorTempPhysicalMin::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "color-temp-physical-max", Attributes::ColorTempPhysicalMax::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "couple-color-temp-to-level-min-mireds", Attributes::CoupleColorTempToLevelMinMireds::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "start-up-color-temperature-mireds", Attributes::StartUpColorTemperatureMireds::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteColorControlColorControlOptions>(credsIssuerConfig), //
make_unique<WriteColorControlWhitePointX>(credsIssuerConfig), //
make_unique<WriteColorControlWhitePointY>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointRX>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointRY>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointRIntensity>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointGX>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointGY>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointGIntensity>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointBX>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointBY>(credsIssuerConfig), //
make_unique<WriteColorControlColorPointBIntensity>(credsIssuerConfig), //
make_unique<WriteColorControlStartUpColorTemperatureMireds>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-hue", Attributes::CurrentHue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-saturation", Attributes::CurrentSaturation::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-x", Attributes::CurrentX::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-y", Attributes::CurrentY::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "drift-compensation", Attributes::DriftCompensation::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "compensation-text", Attributes::CompensationText::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-temperature", Attributes::ColorTemperature::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-mode", Attributes::ColorMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-control-options", Attributes::ColorControlOptions::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-primaries", Attributes::NumberOfPrimaries::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary1x", Attributes::Primary1X::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary1y", Attributes::Primary1Y::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary1intensity", Attributes::Primary1Intensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary2x", Attributes::Primary2X::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary2y", Attributes::Primary2Y::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary2intensity", Attributes::Primary2Intensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary3x", Attributes::Primary3X::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary3y", Attributes::Primary3Y::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary3intensity", Attributes::Primary3Intensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary4x", Attributes::Primary4X::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary4y", Attributes::Primary4Y::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary4intensity", Attributes::Primary4Intensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary5x", Attributes::Primary5X::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary5y", Attributes::Primary5Y::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary5intensity", Attributes::Primary5Intensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary6x", Attributes::Primary6X::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary6y", Attributes::Primary6Y::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "primary6intensity", Attributes::Primary6Intensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "white-point-x", Attributes::WhitePointX::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "white-point-y", Attributes::WhitePointY::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-rx", Attributes::ColorPointRX::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-ry", Attributes::ColorPointRY::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-rintensity", Attributes::ColorPointRIntensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-gx", Attributes::ColorPointGX::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-gy", Attributes::ColorPointGY::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-gintensity", Attributes::ColorPointGIntensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-bx", Attributes::ColorPointBX::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-by", Attributes::ColorPointBY::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-point-bintensity", Attributes::ColorPointBIntensity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enhanced-current-hue", Attributes::EnhancedCurrentHue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enhanced-color-mode", Attributes::EnhancedColorMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-loop-active", Attributes::ColorLoopActive::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-loop-direction", Attributes::ColorLoopDirection::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-loop-time", Attributes::ColorLoopTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-loop-start-enhanced-hue", Attributes::ColorLoopStartEnhancedHue::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-loop-stored-enhanced-hue", Attributes::ColorLoopStoredEnhancedHue::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-capabilities", Attributes::ColorCapabilities::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-temp-physical-min", Attributes::ColorTempPhysicalMin::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "color-temp-physical-max", Attributes::ColorTempPhysicalMax::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "couple-color-temp-to-level-min-mireds",
Attributes::CoupleColorTempToLevelMinMireds::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "start-up-color-temperature-mireds", Attributes::StartUpColorTemperatureMireds::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterContentLauncher(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ContentLauncher;
const char * clusterName = "ContentLauncher";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ContentLauncherLaunchContentRequest>(credsIssuerConfig), //
make_unique<ContentLauncherLaunchURLRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "accept-header-list", Attributes::AcceptHeaderList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "supported-streaming-protocols", Attributes::SupportedStreamingProtocols::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteContentLauncherSupportedStreamingProtocols>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "accept-header-list", Attributes::AcceptHeaderList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "supported-streaming-protocols", Attributes::SupportedStreamingProtocols::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterDescriptor(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Descriptor;
const char * clusterName = "Descriptor";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "device-list", Attributes::DeviceList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-list", Attributes::ServerList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-list", Attributes::ClientList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "parts-list", Attributes::PartsList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "device-list", Attributes::DeviceList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-list", Attributes::ServerList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-list", Attributes::ClientList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "parts-list", Attributes::PartsList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterDiagnosticLogs(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::DiagnosticLogs;
const char * clusterName = "DiagnosticLogs";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<DiagnosticLogsRetrieveLogsRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterDoorLock(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::DoorLock;
const char * clusterName = "DoorLock";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<DoorLockClearCredential>(credsIssuerConfig), //
make_unique<DoorLockClearUser>(credsIssuerConfig), //
make_unique<DoorLockClearWeekDaySchedule>(credsIssuerConfig), //
make_unique<DoorLockClearYearDaySchedule>(credsIssuerConfig), //
make_unique<DoorLockGetCredentialStatus>(credsIssuerConfig), //
make_unique<DoorLockGetUser>(credsIssuerConfig), //
make_unique<DoorLockGetWeekDaySchedule>(credsIssuerConfig), //
make_unique<DoorLockGetYearDaySchedule>(credsIssuerConfig), //
make_unique<DoorLockLockDoor>(credsIssuerConfig), //
make_unique<DoorLockSetCredential>(credsIssuerConfig), //
make_unique<DoorLockSetUser>(credsIssuerConfig), //
make_unique<DoorLockSetWeekDaySchedule>(credsIssuerConfig), //
make_unique<DoorLockSetYearDaySchedule>(credsIssuerConfig), //
make_unique<DoorLockUnlockDoor>(credsIssuerConfig), //
make_unique<DoorLockUnlockWithTimeout>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "lock-state", Attributes::LockState::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "lock-type", Attributes::LockType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "actuator-enabled", Attributes::ActuatorEnabled::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "door-state", Attributes::DoorState::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-total-users-supported", Attributes::NumberOfTotalUsersSupported::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-pinusers-supported", Attributes::NumberOfPINUsersSupported::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-rfidusers-supported", Attributes::NumberOfRFIDUsersSupported::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-week-day-schedules-supported-per-user",
Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-year-day-schedules-supported-per-user",
Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-pincode-length", Attributes::MaxPINCodeLength::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-pincode-length", Attributes::MinPINCodeLength::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-rfidcode-length", Attributes::MaxRFIDCodeLength::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-rfidcode-length", Attributes::MinRFIDCodeLength::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "language", Attributes::Language::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "auto-relock-time", Attributes::AutoRelockTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "sound-volume", Attributes::SoundVolume::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "supported-operating-modes", Attributes::SupportedOperatingModes::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enable-one-touch-locking", Attributes::EnableOneTouchLocking::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enable-privacy-mode-button", Attributes::EnablePrivacyModeButton::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "wrong-code-entry-limit", Attributes::WrongCodeEntryLimit::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteDoorLockLanguage>(credsIssuerConfig), //
make_unique<WriteDoorLockAutoRelockTime>(credsIssuerConfig), //
make_unique<WriteDoorLockSoundVolume>(credsIssuerConfig), //
make_unique<WriteDoorLockOperatingMode>(credsIssuerConfig), //
make_unique<WriteDoorLockEnableOneTouchLocking>(credsIssuerConfig), //
make_unique<WriteDoorLockEnablePrivacyModeButton>(credsIssuerConfig), //
make_unique<WriteDoorLockWrongCodeEntryLimit>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "lock-state", Attributes::LockState::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "lock-type", Attributes::LockType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "actuator-enabled", Attributes::ActuatorEnabled::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "door-state", Attributes::DoorState::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-total-users-supported", Attributes::NumberOfTotalUsersSupported::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-pinusers-supported", Attributes::NumberOfPINUsersSupported::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-rfidusers-supported", Attributes::NumberOfRFIDUsersSupported::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-week-day-schedules-supported-per-user",
Attributes::NumberOfWeekDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-year-day-schedules-supported-per-user",
Attributes::NumberOfYearDaySchedulesSupportedPerUser::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-pincode-length", Attributes::MaxPINCodeLength::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-pincode-length", Attributes::MinPINCodeLength::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-rfidcode-length", Attributes::MaxRFIDCodeLength::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-rfidcode-length", Attributes::MinRFIDCodeLength::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "language", Attributes::Language::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "auto-relock-time", Attributes::AutoRelockTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "sound-volume", Attributes::SoundVolume::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "operating-mode", Attributes::OperatingMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "supported-operating-modes", Attributes::SupportedOperatingModes::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enable-one-touch-locking", Attributes::EnableOneTouchLocking::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enable-privacy-mode-button", Attributes::EnablePrivacyModeButton::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "wrong-code-entry-limit", Attributes::WrongCodeEntryLimit::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "door-lock-alarm", Events::DoorLockAlarm::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "door-state-change", Events::DoorStateChange::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "lock-operation", Events::LockOperation::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "lock-operation-error", Events::LockOperationError::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "lock-user-change", Events::LockUserChange::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "door-lock-alarm", Events::DoorLockAlarm::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "door-state-change", Events::DoorStateChange::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "lock-operation", Events::LockOperation::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "lock-operation-error", Events::LockOperationError::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "lock-user-change", Events::LockUserChange::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterElectricalMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ElectricalMeasurement;
const char * clusterName = "ElectricalMeasurement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "measurement-type", Attributes::MeasurementType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "total-active-power", Attributes::TotalActivePower::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rms-voltage", Attributes::RmsVoltage::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rms-voltage-min", Attributes::RmsVoltageMin::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rms-voltage-max", Attributes::RmsVoltageMax::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rms-current", Attributes::RmsCurrent::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rms-current-min", Attributes::RmsCurrentMin::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rms-current-max", Attributes::RmsCurrentMax::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-power-min", Attributes::ActivePowerMin::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-power-max", Attributes::ActivePowerMax::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "measurement-type", Attributes::MeasurementType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "total-active-power", Attributes::TotalActivePower::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rms-voltage", Attributes::RmsVoltage::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rms-voltage-min", Attributes::RmsVoltageMin::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rms-voltage-max", Attributes::RmsVoltageMax::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rms-current", Attributes::RmsCurrent::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rms-current-min", Attributes::RmsCurrentMin::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rms-current-max", Attributes::RmsCurrentMax::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-power", Attributes::ActivePower::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-power-min", Attributes::ActivePowerMin::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-power-max", Attributes::ActivePowerMax::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterEthernetNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::EthernetNetworkDiagnostics;
const char * clusterName = "EthernetNetworkDiagnostics";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<EthernetNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "phyrate", Attributes::PHYRate::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "full-duplex", Attributes::FullDuplex::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "packet-rx-count", Attributes::PacketRxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "packet-tx-count", Attributes::PacketTxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-err-count", Attributes::TxErrCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "collision-count", Attributes::CollisionCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "carrier-detect", Attributes::CarrierDetect::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "time-since-reset", Attributes::TimeSinceReset::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "phyrate", Attributes::PHYRate::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "full-duplex", Attributes::FullDuplex::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "packet-rx-count", Attributes::PacketRxCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "packet-tx-count", Attributes::PacketTxCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-err-count", Attributes::TxErrCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "collision-count", Attributes::CollisionCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "carrier-detect", Attributes::CarrierDetect::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "time-since-reset", Attributes::TimeSinceReset::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterFixedLabel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::FixedLabel;
const char * clusterName = "FixedLabel";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterFlowMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::FlowMeasurement;
const char * clusterName = "FlowMeasurement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterGeneralCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::GeneralCommissioning;
const char * clusterName = "GeneralCommissioning";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<GeneralCommissioningArmFailSafe>(credsIssuerConfig), //
make_unique<GeneralCommissioningCommissioningComplete>(credsIssuerConfig), //
make_unique<GeneralCommissioningSetRegulatoryConfig>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "breadcrumb", Attributes::Breadcrumb::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "regulatory-config", Attributes::RegulatoryConfig::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "location-capability", Attributes::LocationCapability::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteGeneralCommissioningBreadcrumb>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "breadcrumb", Attributes::Breadcrumb::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "basic-commissioning-info", Attributes::BasicCommissioningInfo::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "regulatory-config", Attributes::RegulatoryConfig::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "location-capability", Attributes::LocationCapability::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterGeneralDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::GeneralDiagnostics;
const char * clusterName = "GeneralDiagnostics";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "network-interfaces", Attributes::NetworkInterfaces::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "reboot-count", Attributes::RebootCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "up-time", Attributes::UpTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "total-operational-hours", Attributes::TotalOperationalHours::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "boot-reasons", Attributes::BootReasons::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "network-interfaces", Attributes::NetworkInterfaces::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "reboot-count", Attributes::RebootCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "up-time", Attributes::UpTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "total-operational-hours", Attributes::TotalOperationalHours::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "boot-reasons", Attributes::BootReasons::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-hardware-faults", Attributes::ActiveHardwareFaults::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-radio-faults", Attributes::ActiveRadioFaults::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-network-faults", Attributes::ActiveNetworkFaults::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "hardware-fault-change", Events::HardwareFaultChange::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "radio-fault-change", Events::RadioFaultChange::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "boot-reason", Events::BootReason::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "hardware-fault-change", Events::HardwareFaultChange::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "radio-fault-change", Events::RadioFaultChange::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "network-fault-change", Events::NetworkFaultChange::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "boot-reason", Events::BootReason::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterGroupKeyManagement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::GroupKeyManagement;
const char * clusterName = "GroupKeyManagement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<GroupKeyManagementKeySetRead>(credsIssuerConfig), //
make_unique<GroupKeyManagementKeySetReadAllIndices>(credsIssuerConfig), //
make_unique<GroupKeyManagementKeySetRemove>(credsIssuerConfig), //
make_unique<GroupKeyManagementKeySetWrite>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "group-key-map", Attributes::GroupKeyMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "group-table", Attributes::GroupTable::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-groups-per-fabric", Attributes::MaxGroupsPerFabric::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-group-keys-per-fabric", Attributes::MaxGroupKeysPerFabric::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteGroupKeyManagementGroupKeyMap>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "group-key-map", Attributes::GroupKeyMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "group-table", Attributes::GroupTable::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-groups-per-fabric", Attributes::MaxGroupsPerFabric::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-group-keys-per-fabric", Attributes::MaxGroupKeysPerFabric::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterGroups(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Groups;
const char * clusterName = "Groups";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<GroupsAddGroup>(credsIssuerConfig), //
make_unique<GroupsAddGroupIfIdentifying>(credsIssuerConfig), //
make_unique<GroupsGetGroupMembership>(credsIssuerConfig), //
make_unique<GroupsRemoveAllGroups>(credsIssuerConfig), //
make_unique<GroupsRemoveGroup>(credsIssuerConfig), //
make_unique<GroupsViewGroup>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterIdentify(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Identify;
const char * clusterName = "Identify";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<IdentifyIdentify>(credsIssuerConfig), //
make_unique<IdentifyIdentifyQuery>(credsIssuerConfig), //
make_unique<IdentifyTriggerEffect>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "identify-time", Attributes::IdentifyTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "identify-type", Attributes::IdentifyType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteIdentifyIdentifyTime>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "identify-time", Attributes::IdentifyTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "identify-type", Attributes::IdentifyType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterIlluminanceMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::IlluminanceMeasurement;
const char * clusterName = "IlluminanceMeasurement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "light-sensor-type", Attributes::LightSensorType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "light-sensor-type", Attributes::LightSensorType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterKeypadInput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::KeypadInput;
const char * clusterName = "KeypadInput";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<KeypadInputSendKeyRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterLevelControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::LevelControl;
const char * clusterName = "LevelControl";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<LevelControlMove>(credsIssuerConfig), //
make_unique<LevelControlMoveToLevel>(credsIssuerConfig), //
make_unique<LevelControlMoveToLevelWithOnOff>(credsIssuerConfig), //
make_unique<LevelControlMoveWithOnOff>(credsIssuerConfig), //
make_unique<LevelControlStep>(credsIssuerConfig), //
make_unique<LevelControlStepWithOnOff>(credsIssuerConfig), //
make_unique<LevelControlStop>(credsIssuerConfig), //
make_unique<LevelControlStopWithOnOff>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-frequency", Attributes::CurrentFrequency::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-frequency", Attributes::MinFrequency::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-frequency", Attributes::MaxFrequency::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "on-off-transition-time", Attributes::OnOffTransitionTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "on-level", Attributes::OnLevel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "on-transition-time", Attributes::OnTransitionTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "off-transition-time", Attributes::OffTransitionTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "default-move-rate", Attributes::DefaultMoveRate::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "start-up-current-level", Attributes::StartUpCurrentLevel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteLevelControlOptions>(credsIssuerConfig), //
make_unique<WriteLevelControlOnOffTransitionTime>(credsIssuerConfig), //
make_unique<WriteLevelControlOnLevel>(credsIssuerConfig), //
make_unique<WriteLevelControlOnTransitionTime>(credsIssuerConfig), //
make_unique<WriteLevelControlOffTransitionTime>(credsIssuerConfig), //
make_unique<WriteLevelControlDefaultMoveRate>(credsIssuerConfig), //
make_unique<WriteLevelControlStartUpCurrentLevel>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-level", Attributes::CurrentLevel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "remaining-time", Attributes::RemainingTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-level", Attributes::MinLevel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-level", Attributes::MaxLevel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-frequency", Attributes::CurrentFrequency::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-frequency", Attributes::MinFrequency::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-frequency", Attributes::MaxFrequency::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "options", Attributes::Options::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "on-off-transition-time", Attributes::OnOffTransitionTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "on-level", Attributes::OnLevel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "on-transition-time", Attributes::OnTransitionTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "off-transition-time", Attributes::OffTransitionTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "default-move-rate", Attributes::DefaultMoveRate::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "start-up-current-level", Attributes::StartUpCurrentLevel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterLocalizationConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::LocalizationConfiguration;
const char * clusterName = "LocalizationConfiguration";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-locale", Attributes::ActiveLocale::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "supported-locales", Attributes::SupportedLocales::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteLocalizationConfigurationActiveLocale>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-locale", Attributes::ActiveLocale::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "supported-locales", Attributes::SupportedLocales::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterLowPower(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::LowPower;
const char * clusterName = "LowPower";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<LowPowerSleep>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterMediaInput(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::MediaInput;
const char * clusterName = "MediaInput";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<MediaInputHideInputStatusRequest>(credsIssuerConfig), //
make_unique<MediaInputRenameInputRequest>(credsIssuerConfig), //
make_unique<MediaInputSelectInputRequest>(credsIssuerConfig), //
make_unique<MediaInputShowInputStatusRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "media-input-list", Attributes::MediaInputList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-media-input", Attributes::CurrentMediaInput::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "media-input-list", Attributes::MediaInputList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-media-input", Attributes::CurrentMediaInput::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterMediaPlayback(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::MediaPlayback;
const char * clusterName = "MediaPlayback";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<MediaPlaybackFastForwardRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackNextRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackPauseRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackPlayRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackPreviousRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackRewindRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackSeekRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackSkipBackwardRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackSkipForwardRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackStartOverRequest>(credsIssuerConfig), //
make_unique<MediaPlaybackStopRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "playback-state", Attributes::PlaybackState::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "start-time", Attributes::StartTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "duration", Attributes::Duration::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "position", Attributes::Position::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "playback-speed", Attributes::PlaybackSpeed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "seek-range-end", Attributes::SeekRangeEnd::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "seek-range-start", Attributes::SeekRangeStart::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteMediaPlaybackPosition>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "playback-state", Attributes::PlaybackState::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "start-time", Attributes::StartTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "duration", Attributes::Duration::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "position", Attributes::Position::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "playback-speed", Attributes::PlaybackSpeed::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "seek-range-end", Attributes::SeekRangeEnd::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "seek-range-start", Attributes::SeekRangeStart::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterModeSelect(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ModeSelect;
const char * clusterName = "ModeSelect";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ModeSelectChangeToMode>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteModeSelectOnMode>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-mode", Attributes::CurrentMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "supported-modes", Attributes::SupportedModes::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "on-mode", Attributes::OnMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "start-up-mode", Attributes::StartUpMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterNetworkCommissioning(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::NetworkCommissioning;
const char * clusterName = "NetworkCommissioning";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<NetworkCommissioningAddOrUpdateThreadNetwork>(credsIssuerConfig), //
make_unique<NetworkCommissioningAddOrUpdateWiFiNetwork>(credsIssuerConfig), //
make_unique<NetworkCommissioningConnectNetwork>(credsIssuerConfig), //
make_unique<NetworkCommissioningRemoveNetwork>(credsIssuerConfig), //
make_unique<NetworkCommissioningReorderNetwork>(credsIssuerConfig), //
make_unique<NetworkCommissioningScanNetworks>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-networks", Attributes::MaxNetworks::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "networks", Attributes::Networks::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "scan-max-time-seconds", Attributes::ScanMaxTimeSeconds::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "connect-max-time-seconds", Attributes::ConnectMaxTimeSeconds::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "last-networking-status", Attributes::LastNetworkingStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "last-network-id", Attributes::LastNetworkID::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "last-connect-error-value", Attributes::LastConnectErrorValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteNetworkCommissioningInterfaceEnabled>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-networks", Attributes::MaxNetworks::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "networks", Attributes::Networks::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "scan-max-time-seconds", Attributes::ScanMaxTimeSeconds::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "connect-max-time-seconds", Attributes::ConnectMaxTimeSeconds::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "interface-enabled", Attributes::InterfaceEnabled::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "last-networking-status", Attributes::LastNetworkingStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "last-network-id", Attributes::LastNetworkID::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "last-connect-error-value", Attributes::LastConnectErrorValue::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterOtaSoftwareUpdateProvider(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::OtaSoftwareUpdateProvider;
const char * clusterName = "OtaSoftwareUpdateProvider";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<OtaSoftwareUpdateProviderApplyUpdateRequest>(credsIssuerConfig), //
make_unique<OtaSoftwareUpdateProviderNotifyUpdateApplied>(credsIssuerConfig), //
make_unique<OtaSoftwareUpdateProviderQueryImage>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterOtaSoftwareUpdateRequestor(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::OtaSoftwareUpdateRequestor;
const char * clusterName = "OtaSoftwareUpdateRequestor";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<OtaSoftwareUpdateRequestorAnnounceOtaProvider>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "default-ota-providers", Attributes::DefaultOtaProviders::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "update-possible", Attributes::UpdatePossible::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "update-state", Attributes::UpdateState::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "update-state-progress", Attributes::UpdateStateProgress::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteOtaSoftwareUpdateRequestorDefaultOtaProviders>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "default-ota-providers", Attributes::DefaultOtaProviders::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "update-possible", Attributes::UpdatePossible::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "update-state", Attributes::UpdateState::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "update-state-progress", Attributes::UpdateStateProgress::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "state-transition", Events::StateTransition::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "version-applied", Events::VersionApplied::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "download-error", Events::DownloadError::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "state-transition", Events::StateTransition::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "version-applied", Events::VersionApplied::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "download-error", Events::DownloadError::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterOccupancySensing(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::OccupancySensing;
const char * clusterName = "OccupancySensing";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "occupancy-sensor-type", Attributes::OccupancySensorType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "occupancy-sensor-type-bitmap", Attributes::OccupancySensorTypeBitmap::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "occupancy", Attributes::Occupancy::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "occupancy-sensor-type", Attributes::OccupancySensorType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "occupancy-sensor-type-bitmap", Attributes::OccupancySensorTypeBitmap::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterOnOff(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::OnOff;
const char * clusterName = "OnOff";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<OnOffOff>(credsIssuerConfig), //
make_unique<OnOffOffWithEffect>(credsIssuerConfig), //
make_unique<OnOffOn>(credsIssuerConfig), //
make_unique<OnOffOnWithRecallGlobalScene>(credsIssuerConfig), //
make_unique<OnOffOnWithTimedOff>(credsIssuerConfig), //
make_unique<OnOffToggle>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "on-off", Attributes::OnOff::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "global-scene-control", Attributes::GlobalSceneControl::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "on-time", Attributes::OnTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "off-wait-time", Attributes::OffWaitTime::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "start-up-on-off", Attributes::StartUpOnOff::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteOnOffOnTime>(credsIssuerConfig), //
make_unique<WriteOnOffOffWaitTime>(credsIssuerConfig), //
make_unique<WriteOnOffStartUpOnOff>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "on-off", Attributes::OnOff::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "global-scene-control", Attributes::GlobalSceneControl::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "on-time", Attributes::OnTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "off-wait-time", Attributes::OffWaitTime::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "start-up-on-off", Attributes::StartUpOnOff::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterOnOffSwitchConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::OnOffSwitchConfiguration;
const char * clusterName = "OnOffSwitchConfiguration";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "switch-type", Attributes::SwitchType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "switch-actions", Attributes::SwitchActions::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteOnOffSwitchConfigurationSwitchActions>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "switch-type", Attributes::SwitchType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "switch-actions", Attributes::SwitchActions::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterOperationalCredentials(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::OperationalCredentials;
const char * clusterName = "OperationalCredentials";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<OperationalCredentialsAddNOC>(credsIssuerConfig), //
make_unique<OperationalCredentialsAddTrustedRootCertificate>(credsIssuerConfig), //
make_unique<OperationalCredentialsAttestationRequest>(credsIssuerConfig), //
make_unique<OperationalCredentialsCSRRequest>(credsIssuerConfig), //
make_unique<OperationalCredentialsCertificateChainRequest>(credsIssuerConfig), //
make_unique<OperationalCredentialsRemoveFabric>(credsIssuerConfig), //
make_unique<OperationalCredentialsRemoveTrustedRootCertificate>(credsIssuerConfig), //
make_unique<OperationalCredentialsUpdateFabricLabel>(credsIssuerConfig), //
make_unique<OperationalCredentialsUpdateNOC>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nocs", Attributes::NOCs::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "fabrics-list", Attributes::FabricsList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "supported-fabrics", Attributes::SupportedFabrics::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "commissioned-fabrics", Attributes::CommissionedFabrics::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-fabric-index", Attributes::CurrentFabricIndex::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nocs", Attributes::NOCs::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "fabrics-list", Attributes::FabricsList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "supported-fabrics", Attributes::SupportedFabrics::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "commissioned-fabrics", Attributes::CommissionedFabrics::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "trusted-root-certificates", Attributes::TrustedRootCertificates::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-fabric-index", Attributes::CurrentFabricIndex::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterPowerSource(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::PowerSource;
const char * clusterName = "PowerSource";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "order", Attributes::Order::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "battery-voltage", Attributes::BatteryVoltage::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "battery-percent-remaining", Attributes::BatteryPercentRemaining::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "battery-time-remaining", Attributes::BatteryTimeRemaining::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "battery-charge-level", Attributes::BatteryChargeLevel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-battery-faults", Attributes::ActiveBatteryFaults::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "battery-charge-state", Attributes::BatteryChargeState::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "status", Attributes::Status::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "order", Attributes::Order::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "description", Attributes::Description::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "battery-voltage", Attributes::BatteryVoltage::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "battery-percent-remaining", Attributes::BatteryPercentRemaining::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "battery-time-remaining", Attributes::BatteryTimeRemaining::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "battery-charge-level", Attributes::BatteryChargeLevel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-battery-faults", Attributes::ActiveBatteryFaults::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "battery-charge-state", Attributes::BatteryChargeState::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterPowerSourceConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::PowerSourceConfiguration;
const char * clusterName = "PowerSourceConfiguration";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "sources", Attributes::Sources::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "sources", Attributes::Sources::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterPressureMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::PressureMeasurement;
const char * clusterName = "PressureMeasurement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterPumpConfigurationAndControl(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::PumpConfigurationAndControl;
const char * clusterName = "PumpConfigurationAndControl";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-pressure", Attributes::MaxPressure::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-speed", Attributes::MaxSpeed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-flow", Attributes::MaxFlow::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-const-pressure", Attributes::MinConstPressure::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-const-pressure", Attributes::MaxConstPressure::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-comp-pressure", Attributes::MinCompPressure::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-comp-pressure", Attributes::MaxCompPressure::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-const-speed", Attributes::MinConstSpeed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-const-speed", Attributes::MaxConstSpeed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-const-flow", Attributes::MinConstFlow::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-const-flow", Attributes::MaxConstFlow::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-const-temp", Attributes::MinConstTemp::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-const-temp", Attributes::MaxConstTemp::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "pump-status", Attributes::PumpStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "effective-operation-mode", Attributes::EffectiveOperationMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "effective-control-mode", Attributes::EffectiveControlMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "capacity", Attributes::Capacity::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "speed", Attributes::Speed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "lifetime-running-hours", Attributes::LifetimeRunningHours::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "power", Attributes::Power::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "lifetime-energy-consumed", Attributes::LifetimeEnergyConsumed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "operation-mode", Attributes::OperationMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "control-mode", Attributes::ControlMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "alarm-mask", Attributes::AlarmMask::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WritePumpConfigurationAndControlLifetimeRunningHours>(credsIssuerConfig), //
make_unique<WritePumpConfigurationAndControlLifetimeEnergyConsumed>(credsIssuerConfig), //
make_unique<WritePumpConfigurationAndControlOperationMode>(credsIssuerConfig), //
make_unique<WritePumpConfigurationAndControlControlMode>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-pressure", Attributes::MaxPressure::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-speed", Attributes::MaxSpeed::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-flow", Attributes::MaxFlow::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-const-pressure", Attributes::MinConstPressure::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-const-pressure", Attributes::MaxConstPressure::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-comp-pressure", Attributes::MinCompPressure::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-comp-pressure", Attributes::MaxCompPressure::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-const-speed", Attributes::MinConstSpeed::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-const-speed", Attributes::MaxConstSpeed::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-const-flow", Attributes::MinConstFlow::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-const-flow", Attributes::MaxConstFlow::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-const-temp", Attributes::MinConstTemp::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-const-temp", Attributes::MaxConstTemp::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "pump-status", Attributes::PumpStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "effective-operation-mode", Attributes::EffectiveOperationMode::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "effective-control-mode", Attributes::EffectiveControlMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "capacity", Attributes::Capacity::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "speed", Attributes::Speed::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "lifetime-running-hours", Attributes::LifetimeRunningHours::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "power", Attributes::Power::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "lifetime-energy-consumed", Attributes::LifetimeEnergyConsumed::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "operation-mode", Attributes::OperationMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "control-mode", Attributes::ControlMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "alarm-mask", Attributes::AlarmMask::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "supply-voltage-low", Events::SupplyVoltageLow::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "supply-voltage-high", Events::SupplyVoltageHigh::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "power-missing-phase", Events::PowerMissingPhase::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "system-pressure-low", Events::SystemPressureLow::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "system-pressure-high", Events::SystemPressureHigh::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "dry-running", Events::DryRunning::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "motor-temperature-high", Events::MotorTemperatureHigh::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "pump-motor-fatal-failure", Events::PumpMotorFatalFailure::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "electronic-temperature-high", Events::ElectronicTemperatureHigh::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "pump-blocked", Events::PumpBlocked::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "sensor-failure", Events::SensorFailure::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "electronic-non-fatal-failure", Events::ElectronicNonFatalFailure::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "electronic-fatal-failure", Events::ElectronicFatalFailure::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "general-fault", Events::GeneralFault::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "leakage", Events::Leakage::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "air-detection", Events::AirDetection::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "turbine-operation", Events::TurbineOperation::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "supply-voltage-low", Events::SupplyVoltageLow::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "supply-voltage-high", Events::SupplyVoltageHigh::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "power-missing-phase", Events::PowerMissingPhase::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "system-pressure-low", Events::SystemPressureLow::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "system-pressure-high", Events::SystemPressureHigh::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "dry-running", Events::DryRunning::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "motor-temperature-high", Events::MotorTemperatureHigh::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "pump-motor-fatal-failure", Events::PumpMotorFatalFailure::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "electronic-temperature-high", Events::ElectronicTemperatureHigh::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "pump-blocked", Events::PumpBlocked::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "sensor-failure", Events::SensorFailure::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "electronic-non-fatal-failure", Events::ElectronicNonFatalFailure::Id,
credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "electronic-fatal-failure", Events::ElectronicFatalFailure::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "general-fault", Events::GeneralFault::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "leakage", Events::Leakage::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "air-detection", Events::AirDetection::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "turbine-operation", Events::TurbineOperation::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterRelativeHumidityMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::RelativeHumidityMeasurement;
const char * clusterName = "RelativeHumidityMeasurement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterScenes(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Scenes;
const char * clusterName = "Scenes";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ScenesAddScene>(credsIssuerConfig), //
make_unique<ScenesGetSceneMembership>(credsIssuerConfig), //
make_unique<ScenesRecallScene>(credsIssuerConfig), //
make_unique<ScenesRemoveAllScenes>(credsIssuerConfig), //
make_unique<ScenesRemoveScene>(credsIssuerConfig), //
make_unique<ScenesStoreScene>(credsIssuerConfig), //
make_unique<ScenesViewScene>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "scene-count", Attributes::SceneCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-scene", Attributes::CurrentScene::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-group", Attributes::CurrentGroup::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "scene-valid", Attributes::SceneValid::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "scene-count", Attributes::SceneCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-scene", Attributes::CurrentScene::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-group", Attributes::CurrentGroup::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "scene-valid", Attributes::SceneValid::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "name-support", Attributes::NameSupport::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterSoftwareDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::SoftwareDiagnostics;
const char * clusterName = "SoftwareDiagnostics";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<SoftwareDiagnosticsResetWatermarks>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "thread-metrics", Attributes::ThreadMetrics::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-heap-free", Attributes::CurrentHeapFree::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-heap-used", Attributes::CurrentHeapUsed::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-heap-high-watermark", Attributes::CurrentHeapHighWatermark::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "thread-metrics", Attributes::ThreadMetrics::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-heap-free", Attributes::CurrentHeapFree::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-heap-used", Attributes::CurrentHeapUsed::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-heap-high-watermark", Attributes::CurrentHeapHighWatermark::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "software-fault", Events::SoftwareFault::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "software-fault", Events::SoftwareFault::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterSwitch(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Switch;
const char * clusterName = "Switch";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-positions", Attributes::NumberOfPositions::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position", Attributes::CurrentPosition::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "multi-press-max", Attributes::MultiPressMax::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-positions", Attributes::NumberOfPositions::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position", Attributes::CurrentPosition::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "multi-press-max", Attributes::MultiPressMax::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "switch-latched", Events::SwitchLatched::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "initial-press", Events::InitialPress::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "long-press", Events::LongPress::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "short-release", Events::ShortRelease::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "long-release", Events::LongRelease::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "multi-press-ongoing", Events::MultiPressOngoing::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "multi-press-complete", Events::MultiPressComplete::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "switch-latched", Events::SwitchLatched::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "initial-press", Events::InitialPress::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "long-press", Events::LongPress::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "short-release", Events::ShortRelease::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "long-release", Events::LongRelease::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "multi-press-ongoing", Events::MultiPressOngoing::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "multi-press-complete", Events::MultiPressComplete::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterTargetNavigator(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::TargetNavigator;
const char * clusterName = "TargetNavigator";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<TargetNavigatorNavigateTargetRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "target-navigator-list", Attributes::TargetNavigatorList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-navigator-target", Attributes::CurrentNavigatorTarget::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "target-navigator-list", Attributes::TargetNavigatorList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-navigator-target", Attributes::CurrentNavigatorTarget::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterTemperatureMeasurement(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::TemperatureMeasurement;
const char * clusterName = "TemperatureMeasurement";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "measured-value", Attributes::MeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-measured-value", Attributes::MinMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-measured-value", Attributes::MaxMeasuredValue::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tolerance", Attributes::Tolerance::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterTestCluster(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::TestCluster;
const char * clusterName = "TestCluster";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<TestClusterSimpleStructEchoRequest>(credsIssuerConfig), //
make_unique<TestClusterTest>(credsIssuerConfig), //
make_unique<TestClusterTestAddArguments>(credsIssuerConfig), //
make_unique<TestClusterTestEmitTestEventRequest>(credsIssuerConfig), //
make_unique<TestClusterTestEnumsRequest>(credsIssuerConfig), //
make_unique<TestClusterTestListInt8UArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestListInt8UReverseRequest>(credsIssuerConfig), //
make_unique<TestClusterTestListNestedStructListArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestListStructArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestNestedStructArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestNestedStructListArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestNotHandled>(credsIssuerConfig), //
make_unique<TestClusterTestNullableOptionalRequest>(credsIssuerConfig), //
make_unique<TestClusterTestSimpleOptionalArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestSpecific>(credsIssuerConfig), //
make_unique<TestClusterTestStructArgumentRequest>(credsIssuerConfig), //
make_unique<TestClusterTestUnknownCommand>(credsIssuerConfig), //
make_unique<TestClusterTimedInvokeRequest>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "boolean", Attributes::Boolean::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "bitmap8", Attributes::Bitmap8::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "bitmap16", Attributes::Bitmap16::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "bitmap32", Attributes::Bitmap32::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "bitmap64", Attributes::Bitmap64::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int8u", Attributes::Int8u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int16u", Attributes::Int16u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int24u", Attributes::Int24u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int32u", Attributes::Int32u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int40u", Attributes::Int40u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int48u", Attributes::Int48u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int56u", Attributes::Int56u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int64u", Attributes::Int64u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int8s", Attributes::Int8s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int16s", Attributes::Int16s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int24s", Attributes::Int24s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int32s", Attributes::Int32s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int40s", Attributes::Int40s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int48s", Attributes::Int48s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int56s", Attributes::Int56s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "int64s", Attributes::Int64s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enum8", Attributes::Enum8::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enum16", Attributes::Enum16::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "float-single", Attributes::FloatSingle::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "float-double", Attributes::FloatDouble::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "octet-string", Attributes::OctetString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "list-int8u", Attributes::ListInt8u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "list-octet-string", Attributes::ListOctetString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "long-octet-string", Attributes::LongOctetString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "char-string", Attributes::CharString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "long-char-string", Attributes::LongCharString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "epoch-us", Attributes::EpochUs::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "epoch-s", Attributes::EpochS::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "enum-attr", Attributes::EnumAttr::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "struct-attr", Attributes::StructAttr::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "range-restricted-int8u", Attributes::RangeRestrictedInt8u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "range-restricted-int8s", Attributes::RangeRestrictedInt8s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "range-restricted-int16u", Attributes::RangeRestrictedInt16u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "range-restricted-int16s", Attributes::RangeRestrictedInt16s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "timed-write-boolean", Attributes::TimedWriteBoolean::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "general-error-boolean", Attributes::GeneralErrorBoolean::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-error-boolean", Attributes::ClusterErrorBoolean::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "unsupported", Attributes::Unsupported::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-boolean", Attributes::NullableBoolean::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-bitmap8", Attributes::NullableBitmap8::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-bitmap16", Attributes::NullableBitmap16::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-bitmap32", Attributes::NullableBitmap32::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-bitmap64", Attributes::NullableBitmap64::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int8u", Attributes::NullableInt8u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int16u", Attributes::NullableInt16u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int24u", Attributes::NullableInt24u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int32u", Attributes::NullableInt32u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int40u", Attributes::NullableInt40u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int48u", Attributes::NullableInt48u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int56u", Attributes::NullableInt56u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int64u", Attributes::NullableInt64u::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int8s", Attributes::NullableInt8s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int16s", Attributes::NullableInt16s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int24s", Attributes::NullableInt24s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int32s", Attributes::NullableInt32s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int40s", Attributes::NullableInt40s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int48s", Attributes::NullableInt48s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int56s", Attributes::NullableInt56s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-int64s", Attributes::NullableInt64s::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-enum8", Attributes::NullableEnum8::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-enum16", Attributes::NullableEnum16::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-float-single", Attributes::NullableFloatSingle::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-float-double", Attributes::NullableFloatDouble::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-octet-string", Attributes::NullableOctetString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-char-string", Attributes::NullableCharString::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-enum-attr", Attributes::NullableEnumAttr::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-struct", Attributes::NullableStruct::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-range-restricted-int8u", Attributes::NullableRangeRestrictedInt8u::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-range-restricted-int8s", Attributes::NullableRangeRestrictedInt8s::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-range-restricted-int16u", Attributes::NullableRangeRestrictedInt16u::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "nullable-range-restricted-int16s", Attributes::NullableRangeRestrictedInt16s::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteTestClusterBoolean>(credsIssuerConfig), //
make_unique<WriteTestClusterBitmap8>(credsIssuerConfig), //
make_unique<WriteTestClusterBitmap16>(credsIssuerConfig), //
make_unique<WriteTestClusterBitmap32>(credsIssuerConfig), //
make_unique<WriteTestClusterBitmap64>(credsIssuerConfig), //
make_unique<WriteTestClusterInt8u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt16u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt24u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt32u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt40u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt48u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt56u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt64u>(credsIssuerConfig), //
make_unique<WriteTestClusterInt8s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt16s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt24s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt32s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt40s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt48s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt56s>(credsIssuerConfig), //
make_unique<WriteTestClusterInt64s>(credsIssuerConfig), //
make_unique<WriteTestClusterEnum8>(credsIssuerConfig), //
make_unique<WriteTestClusterEnum16>(credsIssuerConfig), //
make_unique<WriteTestClusterFloatSingle>(credsIssuerConfig), //
make_unique<WriteTestClusterFloatDouble>(credsIssuerConfig), //
make_unique<WriteTestClusterOctetString>(credsIssuerConfig), //
make_unique<WriteTestClusterListInt8u>(credsIssuerConfig), //
make_unique<WriteTestClusterListOctetString>(credsIssuerConfig), //
make_unique<WriteTestClusterListStructOctetString>(credsIssuerConfig), //
make_unique<WriteTestClusterLongOctetString>(credsIssuerConfig), //
make_unique<WriteTestClusterCharString>(credsIssuerConfig), //
make_unique<WriteTestClusterLongCharString>(credsIssuerConfig), //
make_unique<WriteTestClusterEpochUs>(credsIssuerConfig), //
make_unique<WriteTestClusterEpochS>(credsIssuerConfig), //
make_unique<WriteTestClusterVendorId>(credsIssuerConfig), //
make_unique<WriteTestClusterListNullablesAndOptionalsStruct>(credsIssuerConfig), //
make_unique<WriteTestClusterEnumAttr>(credsIssuerConfig), //
make_unique<WriteTestClusterStructAttr>(credsIssuerConfig), //
make_unique<WriteTestClusterRangeRestrictedInt8u>(credsIssuerConfig), //
make_unique<WriteTestClusterRangeRestrictedInt8s>(credsIssuerConfig), //
make_unique<WriteTestClusterRangeRestrictedInt16u>(credsIssuerConfig), //
make_unique<WriteTestClusterRangeRestrictedInt16s>(credsIssuerConfig), //
make_unique<WriteTestClusterTimedWriteBoolean>(credsIssuerConfig), //
make_unique<WriteTestClusterGeneralErrorBoolean>(credsIssuerConfig), //
make_unique<WriteTestClusterClusterErrorBoolean>(credsIssuerConfig), //
make_unique<WriteTestClusterUnsupported>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableBoolean>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableBitmap8>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableBitmap16>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableBitmap32>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableBitmap64>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt8u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt16u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt24u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt32u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt40u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt48u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt56u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt64u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt8s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt16s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt24s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt32s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt40s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt48s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt56s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableInt64s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableEnum8>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableEnum16>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableFloatSingle>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableFloatDouble>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableOctetString>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableCharString>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableEnumAttr>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableStruct>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableRangeRestrictedInt8u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableRangeRestrictedInt8s>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableRangeRestrictedInt16u>(credsIssuerConfig), //
make_unique<WriteTestClusterNullableRangeRestrictedInt16s>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "boolean", Attributes::Boolean::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "bitmap8", Attributes::Bitmap8::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "bitmap16", Attributes::Bitmap16::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "bitmap32", Attributes::Bitmap32::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "bitmap64", Attributes::Bitmap64::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int8u", Attributes::Int8u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int16u", Attributes::Int16u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int24u", Attributes::Int24u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int32u", Attributes::Int32u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int40u", Attributes::Int40u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int48u", Attributes::Int48u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int56u", Attributes::Int56u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int64u", Attributes::Int64u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int8s", Attributes::Int8s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int16s", Attributes::Int16s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int24s", Attributes::Int24s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int32s", Attributes::Int32s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int40s", Attributes::Int40s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int48s", Attributes::Int48s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int56s", Attributes::Int56s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "int64s", Attributes::Int64s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enum8", Attributes::Enum8::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enum16", Attributes::Enum16::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "float-single", Attributes::FloatSingle::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "float-double", Attributes::FloatDouble::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "octet-string", Attributes::OctetString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "list-int8u", Attributes::ListInt8u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "list-octet-string", Attributes::ListOctetString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "list-struct-octet-string", Attributes::ListStructOctetString::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "long-octet-string", Attributes::LongOctetString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "char-string", Attributes::CharString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "long-char-string", Attributes::LongCharString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "epoch-us", Attributes::EpochUs::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "epoch-s", Attributes::EpochS::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "vendor-id", Attributes::VendorId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "list-nullables-and-optionals-struct", Attributes::ListNullablesAndOptionalsStruct::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "enum-attr", Attributes::EnumAttr::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "struct-attr", Attributes::StructAttr::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "range-restricted-int8u", Attributes::RangeRestrictedInt8u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "range-restricted-int8s", Attributes::RangeRestrictedInt8s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "range-restricted-int16u", Attributes::RangeRestrictedInt16u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "range-restricted-int16s", Attributes::RangeRestrictedInt16s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "list-long-octet-string", Attributes::ListLongOctetString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "timed-write-boolean", Attributes::TimedWriteBoolean::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "general-error-boolean", Attributes::GeneralErrorBoolean::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-error-boolean", Attributes::ClusterErrorBoolean::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "unsupported", Attributes::Unsupported::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-boolean", Attributes::NullableBoolean::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-bitmap8", Attributes::NullableBitmap8::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-bitmap16", Attributes::NullableBitmap16::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-bitmap32", Attributes::NullableBitmap32::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-bitmap64", Attributes::NullableBitmap64::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int8u", Attributes::NullableInt8u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int16u", Attributes::NullableInt16u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int24u", Attributes::NullableInt24u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int32u", Attributes::NullableInt32u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int40u", Attributes::NullableInt40u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int48u", Attributes::NullableInt48u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int56u", Attributes::NullableInt56u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int64u", Attributes::NullableInt64u::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int8s", Attributes::NullableInt8s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int16s", Attributes::NullableInt16s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int24s", Attributes::NullableInt24s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int32s", Attributes::NullableInt32s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int40s", Attributes::NullableInt40s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int48s", Attributes::NullableInt48s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int56s", Attributes::NullableInt56s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-int64s", Attributes::NullableInt64s::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-enum8", Attributes::NullableEnum8::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-enum16", Attributes::NullableEnum16::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-float-single", Attributes::NullableFloatSingle::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-float-double", Attributes::NullableFloatDouble::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-octet-string", Attributes::NullableOctetString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-char-string", Attributes::NullableCharString::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-enum-attr", Attributes::NullableEnumAttr::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-struct", Attributes::NullableStruct::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int8u", Attributes::NullableRangeRestrictedInt8u::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int8s", Attributes::NullableRangeRestrictedInt8s::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int16u", Attributes::NullableRangeRestrictedInt16u::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "nullable-range-restricted-int16s", Attributes::NullableRangeRestrictedInt16s::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "test-event", Events::TestEvent::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "test-fabric-scoped-event", Events::TestFabricScopedEvent::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "test-event", Events::TestEvent::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "test-fabric-scoped-event", Events::TestFabricScopedEvent::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterThermostat(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::Thermostat;
const char * clusterName = "Thermostat";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ThermostatClearWeeklySchedule>(credsIssuerConfig), //
make_unique<ThermostatGetRelayStatusLog>(credsIssuerConfig), //
make_unique<ThermostatGetWeeklySchedule>(credsIssuerConfig), //
make_unique<ThermostatSetWeeklySchedule>(credsIssuerConfig), //
make_unique<ThermostatSetpointRaiseLower>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "local-temperature", Attributes::LocalTemperature::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "abs-min-heat-setpoint-limit", Attributes::AbsMinHeatSetpointLimit::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "abs-max-heat-setpoint-limit", Attributes::AbsMaxHeatSetpointLimit::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "abs-min-cool-setpoint-limit", Attributes::AbsMinCoolSetpointLimit::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "abs-max-cool-setpoint-limit", Attributes::AbsMaxCoolSetpointLimit::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "occupied-cooling-setpoint", Attributes::OccupiedCoolingSetpoint::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "occupied-heating-setpoint", Attributes::OccupiedHeatingSetpoint::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-heat-setpoint-limit", Attributes::MinHeatSetpointLimit::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-heat-setpoint-limit", Attributes::MaxHeatSetpointLimit::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-cool-setpoint-limit", Attributes::MinCoolSetpointLimit::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "max-cool-setpoint-limit", Attributes::MaxCoolSetpointLimit::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "min-setpoint-dead-band", Attributes::MinSetpointDeadBand::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "control-sequence-of-operation", Attributes::ControlSequenceOfOperation::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "system-mode", Attributes::SystemMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "start-of-week", Attributes::StartOfWeek::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-weekly-transitions", Attributes::NumberOfWeeklyTransitions::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "number-of-daily-transitions", Attributes::NumberOfDailyTransitions::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteThermostatOccupiedCoolingSetpoint>(credsIssuerConfig), //
make_unique<WriteThermostatOccupiedHeatingSetpoint>(credsIssuerConfig), //
make_unique<WriteThermostatMinHeatSetpointLimit>(credsIssuerConfig), //
make_unique<WriteThermostatMaxHeatSetpointLimit>(credsIssuerConfig), //
make_unique<WriteThermostatMinCoolSetpointLimit>(credsIssuerConfig), //
make_unique<WriteThermostatMaxCoolSetpointLimit>(credsIssuerConfig), //
make_unique<WriteThermostatMinSetpointDeadBand>(credsIssuerConfig), //
make_unique<WriteThermostatControlSequenceOfOperation>(credsIssuerConfig), //
make_unique<WriteThermostatSystemMode>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "local-temperature", Attributes::LocalTemperature::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "abs-min-heat-setpoint-limit", Attributes::AbsMinHeatSetpointLimit::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "abs-max-heat-setpoint-limit", Attributes::AbsMaxHeatSetpointLimit::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "abs-min-cool-setpoint-limit", Attributes::AbsMinCoolSetpointLimit::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "abs-max-cool-setpoint-limit", Attributes::AbsMaxCoolSetpointLimit::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "occupied-cooling-setpoint", Attributes::OccupiedCoolingSetpoint::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "occupied-heating-setpoint", Attributes::OccupiedHeatingSetpoint::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-heat-setpoint-limit", Attributes::MinHeatSetpointLimit::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-heat-setpoint-limit", Attributes::MaxHeatSetpointLimit::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-cool-setpoint-limit", Attributes::MinCoolSetpointLimit::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "max-cool-setpoint-limit", Attributes::MaxCoolSetpointLimit::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "min-setpoint-dead-band", Attributes::MinSetpointDeadBand::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "control-sequence-of-operation", Attributes::ControlSequenceOfOperation::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "system-mode", Attributes::SystemMode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "start-of-week", Attributes::StartOfWeek::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-weekly-transitions", Attributes::NumberOfWeeklyTransitions::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "number-of-daily-transitions", Attributes::NumberOfDailyTransitions::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterThermostatUserInterfaceConfiguration(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ThermostatUserInterfaceConfiguration;
const char * clusterName = "ThermostatUserInterfaceConfiguration";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "temperature-display-mode", Attributes::TemperatureDisplayMode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "keypad-lockout", Attributes::KeypadLockout::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "schedule-programming-visibility", Attributes::ScheduleProgrammingVisibility::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteThermostatUserInterfaceConfigurationTemperatureDisplayMode>(credsIssuerConfig), //
make_unique<WriteThermostatUserInterfaceConfigurationKeypadLockout>(credsIssuerConfig), //
make_unique<WriteThermostatUserInterfaceConfigurationScheduleProgrammingVisibility>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "temperature-display-mode", Attributes::TemperatureDisplayMode::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "keypad-lockout", Attributes::KeypadLockout::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "schedule-programming-visibility", Attributes::ScheduleProgrammingVisibility::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterThreadNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::ThreadNetworkDiagnostics;
const char * clusterName = "ThreadNetworkDiagnostics";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<ThreadNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "channel", Attributes::Channel::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "routing-role", Attributes::RoutingRole::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "network-name", Attributes::NetworkName::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "pan-id", Attributes::PanId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "extended-pan-id", Attributes::ExtendedPanId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "neighbor-table-list", Attributes::NeighborTableList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "route-table-list", Attributes::RouteTableList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "partition-id", Attributes::PartitionId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "weighting", Attributes::Weighting::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "data-version", Attributes::DataVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "stable-data-version", Attributes::StableDataVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "leader-router-id", Attributes::LeaderRouterId::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "detached-role-count", Attributes::DetachedRoleCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "child-role-count", Attributes::ChildRoleCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "router-role-count", Attributes::RouterRoleCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "leader-role-count", Attributes::LeaderRoleCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attach-attempt-count", Attributes::AttachAttemptCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "partition-id-change-count", Attributes::PartitionIdChangeCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "better-partition-attach-attempt-count", Attributes::BetterPartitionAttachAttemptCount::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "parent-change-count", Attributes::ParentChangeCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-total-count", Attributes::TxTotalCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-unicast-count", Attributes::TxUnicastCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-broadcast-count", Attributes::TxBroadcastCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-ack-requested-count", Attributes::TxAckRequestedCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-acked-count", Attributes::TxAckedCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-no-ack-requested-count", Attributes::TxNoAckRequestedCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-data-count", Attributes::TxDataCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-data-poll-count", Attributes::TxDataPollCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-beacon-count", Attributes::TxBeaconCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-beacon-request-count", Attributes::TxBeaconRequestCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-other-count", Attributes::TxOtherCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-retry-count", Attributes::TxRetryCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-direct-max-retry-expiry-count", Attributes::TxDirectMaxRetryExpiryCount::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-indirect-max-retry-expiry-count", Attributes::TxIndirectMaxRetryExpiryCount::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-err-cca-count", Attributes::TxErrCcaCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-err-abort-count", Attributes::TxErrAbortCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "tx-err-busy-channel-count", Attributes::TxErrBusyChannelCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-total-count", Attributes::RxTotalCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-unicast-count", Attributes::RxUnicastCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-broadcast-count", Attributes::RxBroadcastCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-data-count", Attributes::RxDataCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-data-poll-count", Attributes::RxDataPollCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-beacon-count", Attributes::RxBeaconCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-beacon-request-count", Attributes::RxBeaconRequestCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-other-count", Attributes::RxOtherCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-address-filtered-count", Attributes::RxAddressFilteredCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-dest-addr-filtered-count", Attributes::RxDestAddrFilteredCount::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-duplicated-count", Attributes::RxDuplicatedCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-err-no-frame-count", Attributes::RxErrNoFrameCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-err-unknown-neighbor-count", Attributes::RxErrUnknownNeighborCount::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-err-invalid-src-addr-count", Attributes::RxErrInvalidSrcAddrCount::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-err-sec-count", Attributes::RxErrSecCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-err-fcs-count", Attributes::RxErrFcsCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rx-err-other-count", Attributes::RxErrOtherCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-timestamp", Attributes::ActiveTimestamp::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "pending-timestamp", Attributes::PendingTimestamp::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "delay", Attributes::Delay::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "security-policy", Attributes::SecurityPolicy::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "channel-mask", Attributes::ChannelMask::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "channel", Attributes::Channel::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "routing-role", Attributes::RoutingRole::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "network-name", Attributes::NetworkName::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "pan-id", Attributes::PanId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "extended-pan-id", Attributes::ExtendedPanId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "mesh-local-prefix", Attributes::MeshLocalPrefix::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "neighbor-table-list", Attributes::NeighborTableList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "route-table-list", Attributes::RouteTableList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "partition-id", Attributes::PartitionId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "weighting", Attributes::Weighting::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "data-version", Attributes::DataVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "stable-data-version", Attributes::StableDataVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "leader-router-id", Attributes::LeaderRouterId::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "detached-role-count", Attributes::DetachedRoleCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "child-role-count", Attributes::ChildRoleCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "router-role-count", Attributes::RouterRoleCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "leader-role-count", Attributes::LeaderRoleCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attach-attempt-count", Attributes::AttachAttemptCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "partition-id-change-count", Attributes::PartitionIdChangeCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "better-partition-attach-attempt-count",
Attributes::BetterPartitionAttachAttemptCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "parent-change-count", Attributes::ParentChangeCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-total-count", Attributes::TxTotalCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-unicast-count", Attributes::TxUnicastCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-broadcast-count", Attributes::TxBroadcastCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-ack-requested-count", Attributes::TxAckRequestedCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-acked-count", Attributes::TxAckedCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-no-ack-requested-count", Attributes::TxNoAckRequestedCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-data-count", Attributes::TxDataCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-data-poll-count", Attributes::TxDataPollCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-beacon-count", Attributes::TxBeaconCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-beacon-request-count", Attributes::TxBeaconRequestCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-other-count", Attributes::TxOtherCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-retry-count", Attributes::TxRetryCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-direct-max-retry-expiry-count", Attributes::TxDirectMaxRetryExpiryCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-indirect-max-retry-expiry-count", Attributes::TxIndirectMaxRetryExpiryCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-err-cca-count", Attributes::TxErrCcaCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-err-abort-count", Attributes::TxErrAbortCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "tx-err-busy-channel-count", Attributes::TxErrBusyChannelCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-total-count", Attributes::RxTotalCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-unicast-count", Attributes::RxUnicastCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-broadcast-count", Attributes::RxBroadcastCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-data-count", Attributes::RxDataCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-data-poll-count", Attributes::RxDataPollCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-beacon-count", Attributes::RxBeaconCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-beacon-request-count", Attributes::RxBeaconRequestCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-other-count", Attributes::RxOtherCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-address-filtered-count", Attributes::RxAddressFilteredCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-dest-addr-filtered-count", Attributes::RxDestAddrFilteredCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-duplicated-count", Attributes::RxDuplicatedCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-err-no-frame-count", Attributes::RxErrNoFrameCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-err-unknown-neighbor-count", Attributes::RxErrUnknownNeighborCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-err-invalid-src-addr-count", Attributes::RxErrInvalidSrcAddrCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-err-sec-count", Attributes::RxErrSecCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-err-fcs-count", Attributes::RxErrFcsCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rx-err-other-count", Attributes::RxErrOtherCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-timestamp", Attributes::ActiveTimestamp::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "pending-timestamp", Attributes::PendingTimestamp::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "delay", Attributes::Delay::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "security-policy", Attributes::SecurityPolicy::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "channel-mask", Attributes::ChannelMask::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "operational-dataset-components", Attributes::OperationalDatasetComponents::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-network-faults-list", Attributes::ActiveNetworkFaultsList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterTimeFormatLocalization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::TimeFormatLocalization;
const char * clusterName = "TimeFormatLocalization";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "hour-format", Attributes::HourFormat::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "active-calendar-type", Attributes::ActiveCalendarType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteTimeFormatLocalizationHourFormat>(credsIssuerConfig), //
make_unique<WriteTimeFormatLocalizationActiveCalendarType>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "hour-format", Attributes::HourFormat::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "active-calendar-type", Attributes::ActiveCalendarType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "supported-calendar-types", Attributes::SupportedCalendarTypes::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterUnitLocalization(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::UnitLocalization;
const char * clusterName = "UnitLocalization";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "temperature-unit", Attributes::TemperatureUnit::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteUnitLocalizationTemperatureUnit>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "temperature-unit", Attributes::TemperatureUnit::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterUserLabel(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::UserLabel;
const char * clusterName = "UserLabel";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteUserLabelLabelList>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "label-list", Attributes::LabelList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterWakeOnLan(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::WakeOnLan;
const char * clusterName = "WakeOnLan";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "wake-on-lan-mac-address", Attributes::WakeOnLanMacAddress::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "wake-on-lan-mac-address", Attributes::WakeOnLanMacAddress::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterWiFiNetworkDiagnostics(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::WiFiNetworkDiagnostics;
const char * clusterName = "WiFiNetworkDiagnostics";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<WiFiNetworkDiagnosticsResetCounts>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "bssid", Attributes::Bssid::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "security-type", Attributes::SecurityType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "wi-fi-version", Attributes::WiFiVersion::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "channel-number", Attributes::ChannelNumber::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "rssi", Attributes::Rssi::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "beacon-lost-count", Attributes::BeaconLostCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "beacon-rx-count", Attributes::BeaconRxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "packet-multicast-rx-count", Attributes::PacketMulticastRxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "packet-multicast-tx-count", Attributes::PacketMulticastTxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "packet-unicast-rx-count", Attributes::PacketUnicastRxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "packet-unicast-tx-count", Attributes::PacketUnicastTxCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-max-rate", Attributes::CurrentMaxRate::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "bssid", Attributes::Bssid::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "security-type", Attributes::SecurityType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "wi-fi-version", Attributes::WiFiVersion::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "channel-number", Attributes::ChannelNumber::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "rssi", Attributes::Rssi::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "beacon-lost-count", Attributes::BeaconLostCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "beacon-rx-count", Attributes::BeaconRxCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "packet-multicast-rx-count", Attributes::PacketMulticastRxCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "packet-multicast-tx-count", Attributes::PacketMulticastTxCount::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "packet-unicast-rx-count", Attributes::PacketUnicastRxCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "packet-unicast-tx-count", Attributes::PacketUnicastTxCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-max-rate", Attributes::CurrentMaxRate::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "overrun-count", Attributes::OverrunCount::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "disconnection", Events::Disconnection::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "association-failure", Events::AssociationFailure::Id, credsIssuerConfig), //
make_unique<ReadEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "disconnection", Events::Disconnection::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "association-failure", Events::AssociationFailure::Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, "connection-status", Events::ConnectionStatus::Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterWindowCovering(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
using namespace chip::app::Clusters::WindowCovering;
const char * clusterName = "WindowCovering";
commands_list clusterCommands = {
//
// Commands
//
make_unique<ClusterCommand>(Id, credsIssuerConfig), //
make_unique<WindowCoveringDownOrClose>(credsIssuerConfig), //
make_unique<WindowCoveringGoToLiftPercentage>(credsIssuerConfig), //
make_unique<WindowCoveringGoToLiftValue>(credsIssuerConfig), //
make_unique<WindowCoveringGoToTiltPercentage>(credsIssuerConfig), //
make_unique<WindowCoveringGoToTiltValue>(credsIssuerConfig), //
make_unique<WindowCoveringStopMotion>(credsIssuerConfig), //
make_unique<WindowCoveringUpOrOpen>(credsIssuerConfig), //
//
// Attributes
//
make_unique<ReadAttribute>(Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "type", Attributes::Type::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position-lift", Attributes::CurrentPositionLift::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position-tilt", Attributes::CurrentPositionTilt::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "config-status", Attributes::ConfigStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position-lift-percentage", Attributes::CurrentPositionLiftPercentage::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position-tilt-percentage", Attributes::CurrentPositionTiltPercentage::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "operational-status", Attributes::OperationalStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "target-position-lift-percent100ths", Attributes::TargetPositionLiftPercent100ths::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "target-position-tilt-percent100ths", Attributes::TargetPositionTiltPercent100ths::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "end-product-type", Attributes::EndProductType::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position-lift-percent100ths", Attributes::CurrentPositionLiftPercent100ths::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "current-position-tilt-percent100ths", Attributes::CurrentPositionTiltPercent100ths::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "installed-open-limit-lift", Attributes::InstalledOpenLimitLift::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "installed-closed-limit-lift", Attributes::InstalledClosedLimitLift::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "installed-open-limit-tilt", Attributes::InstalledOpenLimitTilt::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "installed-closed-limit-tilt", Attributes::InstalledClosedLimitTilt::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "mode", Attributes::Mode::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "safety-status", Attributes::SafetyStatus::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<ReadAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
make_unique<WriteAttribute>(Id, credsIssuerConfig), //
make_unique<WriteWindowCoveringMode>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "type", Attributes::Type::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position-lift", Attributes::CurrentPositionLift::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position-tilt", Attributes::CurrentPositionTilt::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "config-status", Attributes::ConfigStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position-lift-percentage", Attributes::CurrentPositionLiftPercentage::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position-tilt-percentage", Attributes::CurrentPositionTiltPercentage::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "operational-status", Attributes::OperationalStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "target-position-lift-percent100ths", Attributes::TargetPositionLiftPercent100ths::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "target-position-tilt-percent100ths", Attributes::TargetPositionTiltPercent100ths::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "end-product-type", Attributes::EndProductType::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position-lift-percent100ths", Attributes::CurrentPositionLiftPercent100ths::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "current-position-tilt-percent100ths", Attributes::CurrentPositionTiltPercent100ths::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "installed-open-limit-lift", Attributes::InstalledOpenLimitLift::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "installed-closed-limit-lift", Attributes::InstalledClosedLimitLift::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "installed-open-limit-tilt", Attributes::InstalledOpenLimitTilt::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "installed-closed-limit-tilt", Attributes::InstalledClosedLimitTilt::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "mode", Attributes::Mode::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "safety-status", Attributes::SafetyStatus::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "server-generated-command-list", Attributes::ServerGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "client-generated-command-list", Attributes::ClientGeneratedCommandList::Id,
credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "attribute-list", Attributes::AttributeList::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "feature-map", Attributes::FeatureMap::Id, credsIssuerConfig), //
make_unique<SubscribeAttribute>(Id, "cluster-revision", Attributes::ClusterRevision::Id, credsIssuerConfig), //
//
// Events
//
make_unique<ReadEvent>(Id, credsIssuerConfig), //
make_unique<SubscribeEvent>(Id, credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusterAny(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
const char * clusterName = "Any";
commands_list clusterCommands = {
make_unique<ClusterCommand>(credsIssuerConfig), //
make_unique<ReadAttribute>(credsIssuerConfig), //
make_unique<WriteAttribute>(credsIssuerConfig), //
make_unique<SubscribeAttribute>(credsIssuerConfig), //
make_unique<ReadEvent>(credsIssuerConfig), //
make_unique<SubscribeEvent>(credsIssuerConfig), //
};
commands.Register(clusterName, clusterCommands);
}
void registerClusters(Commands & commands, CredentialIssuerCommands * credsIssuerConfig)
{
registerClusterAny(commands, credsIssuerConfig);
registerClusterAccessControl(commands, credsIssuerConfig);
registerClusterAccountLogin(commands, credsIssuerConfig);
registerClusterAdministratorCommissioning(commands, credsIssuerConfig);
registerClusterApplicationBasic(commands, credsIssuerConfig);
registerClusterApplicationLauncher(commands, credsIssuerConfig);
registerClusterAudioOutput(commands, credsIssuerConfig);
registerClusterBarrierControl(commands, credsIssuerConfig);
registerClusterBasic(commands, credsIssuerConfig);
registerClusterBinaryInputBasic(commands, credsIssuerConfig);
registerClusterBinding(commands, credsIssuerConfig);
registerClusterBooleanState(commands, credsIssuerConfig);
registerClusterBridgedActions(commands, credsIssuerConfig);
registerClusterBridgedDeviceBasic(commands, credsIssuerConfig);
registerClusterChannel(commands, credsIssuerConfig);
registerClusterColorControl(commands, credsIssuerConfig);
registerClusterContentLauncher(commands, credsIssuerConfig);
registerClusterDescriptor(commands, credsIssuerConfig);
registerClusterDiagnosticLogs(commands, credsIssuerConfig);
registerClusterDoorLock(commands, credsIssuerConfig);
registerClusterElectricalMeasurement(commands, credsIssuerConfig);
registerClusterEthernetNetworkDiagnostics(commands, credsIssuerConfig);
registerClusterFixedLabel(commands, credsIssuerConfig);
registerClusterFlowMeasurement(commands, credsIssuerConfig);
registerClusterGeneralCommissioning(commands, credsIssuerConfig);
registerClusterGeneralDiagnostics(commands, credsIssuerConfig);
registerClusterGroupKeyManagement(commands, credsIssuerConfig);
registerClusterGroups(commands, credsIssuerConfig);
registerClusterIdentify(commands, credsIssuerConfig);
registerClusterIlluminanceMeasurement(commands, credsIssuerConfig);
registerClusterKeypadInput(commands, credsIssuerConfig);
registerClusterLevelControl(commands, credsIssuerConfig);
registerClusterLocalizationConfiguration(commands, credsIssuerConfig);
registerClusterLowPower(commands, credsIssuerConfig);
registerClusterMediaInput(commands, credsIssuerConfig);
registerClusterMediaPlayback(commands, credsIssuerConfig);
registerClusterModeSelect(commands, credsIssuerConfig);
registerClusterNetworkCommissioning(commands, credsIssuerConfig);
registerClusterOtaSoftwareUpdateProvider(commands, credsIssuerConfig);
registerClusterOtaSoftwareUpdateRequestor(commands, credsIssuerConfig);
registerClusterOccupancySensing(commands, credsIssuerConfig);
registerClusterOnOff(commands, credsIssuerConfig);
registerClusterOnOffSwitchConfiguration(commands, credsIssuerConfig);
registerClusterOperationalCredentials(commands, credsIssuerConfig);
registerClusterPowerSource(commands, credsIssuerConfig);
registerClusterPowerSourceConfiguration(commands, credsIssuerConfig);
registerClusterPressureMeasurement(commands, credsIssuerConfig);
registerClusterPumpConfigurationAndControl(commands, credsIssuerConfig);
registerClusterRelativeHumidityMeasurement(commands, credsIssuerConfig);
registerClusterScenes(commands, credsIssuerConfig);
registerClusterSoftwareDiagnostics(commands, credsIssuerConfig);
registerClusterSwitch(commands, credsIssuerConfig);
registerClusterTargetNavigator(commands, credsIssuerConfig);
registerClusterTemperatureMeasurement(commands, credsIssuerConfig);
registerClusterTestCluster(commands, credsIssuerConfig);
registerClusterThermostat(commands, credsIssuerConfig);
registerClusterThermostatUserInterfaceConfiguration(commands, credsIssuerConfig);
registerClusterThreadNetworkDiagnostics(commands, credsIssuerConfig);
registerClusterTimeFormatLocalization(commands, credsIssuerConfig);
registerClusterUnitLocalization(commands, credsIssuerConfig);
registerClusterUserLabel(commands, credsIssuerConfig);
registerClusterWakeOnLan(commands, credsIssuerConfig);
registerClusterWiFiNetworkDiagnostics(commands, credsIssuerConfig);
registerClusterWindowCovering(commands, credsIssuerConfig);
}