From d83ae8ab75382373fec1648dcd6d371e4b07407c Mon Sep 17 00:00:00 2001 From: Bharat Dandu Date: Mon, 20 Mar 2023 14:03:35 -0400 Subject: [PATCH] Add vendor Id attribute as a template exception Github: ZAP#898 --- .../java/templates/CHIPReadCallbacks-src.zapt | 50 + .../java/templates/CHIPReadCallbacks.zapt | 26 + .../java/templates/ChipClusters-java.zapt | 34 + .../java/templates/ClusterInfo-java.zapt | 33 + .../ClusterInfo-read-interaction.zapt | 8 + .../java/zap-generated/CHIPReadCallbacks.cpp | 230 +++ .../java/zap-generated/CHIPReadCallbacks.h | 121 ++ .../chip/devicecontroller/ChipClusters.java | 64 +- .../devicecontroller/ClusterInfoMapping.java | 96 + .../devicecontroller/ClusterReadMapping.java | 25 +- .../zap-generated/attributes/Accessors.h | 1731 +++++++++-------- 11 files changed, 1531 insertions(+), 887 deletions(-) diff --git a/src/controller/java/templates/CHIPReadCallbacks-src.zapt b/src/controller/java/templates/CHIPReadCallbacks-src.zapt index 2d1b9deb520827..f00c4c9b05e5a1 100644 --- a/src/controller/java/templates/CHIPReadCallbacks-src.zapt +++ b/src/controller/java/templates/CHIPReadCallbacks-src.zapt @@ -92,6 +92,32 @@ void CHIP{{chipCallback.name}}AttributeCallback::CallbackFn(void * context, {{ch {{else}} {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} +CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback::CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback::~CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback() { + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + {{/if}} {{else}} CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback::CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) @@ -146,6 +172,30 @@ void CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallb } {{else}} {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + void CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback::CallbackFn(void * context, {{zapTypeToDecodableClusterObjectType type ns=parent.name isArgument=true}} value) + { + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback(reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#if isArray}}{{else if isStruct}}{{else if isOptional}}Ljava/util/Optional;{{else if (isOctetString type)}}[B{{else if (isCharString type)}}Ljava/lang/String;{{else}}{{asJniSignatureBasic type true}}{{/if}})V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + {{>decode_value source="value" target="javaValue" cluster=(asUpperCamelCase parent.name) depth=0}} + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); + } + {{/if}} {{else}} void CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback::CallbackFn(void * context, {{zapTypeToDecodableClusterObjectType type ns=parent.name isArgument=true}} value) { diff --git a/src/controller/java/templates/CHIPReadCallbacks.zapt b/src/controller/java/templates/CHIPReadCallbacks.zapt index 3b87cd783f82ee..615d353b68b5f5 100644 --- a/src/controller/java/templates/CHIPReadCallbacks.zapt +++ b/src/controller/java/templates/CHIPReadCallbacks.zapt @@ -41,6 +41,32 @@ private: {{#if_unsupported_attribute_callback type isArray ../id}} {{else}} {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} +class CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback : public chip::Callback::Callback +{ +public: + CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback(); + + static void maybeDestroy(CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback * callback) { + if (!callback->keepAlive) { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, {{zapTypeToDecodableClusterObjectType type ns=parent.name isArgument=true}} {{#if isArray}}list{{else}}value{{/if}}); + static void OnSubscriptionEstablished(void * context, chip::SubscriptionId subscriptionId) { + CHIP_ERROR err = chip::JniReferences::GetInstance().CallSubscriptionEstablished(reinterpret_cast(context)->javaCallbackRef, subscriptionId); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error calling onSubscriptionEstablished: %s", ErrorStr(err))); + }; + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + {{/if}} {{else}} class CHIP{{asUpperCamelCase parent.name}}{{asUpperCamelCase name}}AttributeCallback : public chip::Callback::Callback { diff --git a/src/controller/java/templates/ChipClusters-java.zapt b/src/controller/java/templates/ChipClusters-java.zapt index 6737840347b615..b58a4da23b46a1 100644 --- a/src/controller/java/templates/ChipClusters-java.zapt +++ b/src/controller/java/templates/ChipClusters-java.zapt @@ -145,6 +145,24 @@ public class ChipClusters { {{#if_unsupported_attribute_callback type isArray ../id}} {{else}} {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + {{! NOTE: asJavaType ends up sniffing for isArray on the context. Since we want the type of our _entry_, force isArray to + false. }} + {{~#*inline "asJavaTypeForEntry"}}{{asJavaType type null parent.name forceNotList=true}}{{/inline~}} + {{#if isArray}} + public interface {{asUpperCamelCase name}}AttributeCallback { + void onSuccess({{#if isNullable}}@Nullable{{/if}} List<{{>asJavaTypeForEntry isArray=false}}> valueList); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + {{else}} + public interface {{asUpperCamelCase name}}AttributeCallback { + void onSuccess({{#if isNullable}}@Nullable{{/if}} {{>asJavaTypeForEntry isArray=false}} value); + void onError(Exception ex); + default void onSubscriptionEstablished(long subscriptionId) {} + } + {{/if}} + {{/if}} {{else}} {{! NOTE: asJavaType ends up sniffing for isArray on the context. Since we want the type of our _entry_, force isArray to false. }} @@ -172,7 +190,11 @@ public class ChipClusters { public void read{{asUpperCamelCase name}}Attribute( {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + {{asUpperCamelCase name}}AttributeCallback callback + {{else}} {{as_underlying_java_zcl_type type ../id boolean="Boolean"}}AttributeCallback callback + {{/if}} {{else}} {{asUpperCamelCase name}}AttributeCallback callback {{/if_basic_attribute}} @@ -193,7 +215,11 @@ public class ChipClusters { {{#if isReportableAttribute}} public void subscribe{{asCamelCased name false}}Attribute( {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + {{asUpperCamelCase name}}AttributeCallback callback + {{else}} {{as_underlying_java_zcl_type type ../id boolean="Boolean"}}AttributeCallback callback + {{/if}} {{else}} {{asUpperCamelCase name}}AttributeCallback callback {{/if_basic_attribute}}, @@ -210,7 +236,11 @@ public class ChipClusters { private native void read{{asUpperCamelCase name}}Attribute(long chipClusterPtr, {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + {{asUpperCamelCase name}}AttributeCallback callback + {{else}} {{as_underlying_java_zcl_type type ../id boolean="Boolean"}}AttributeCallback callback + {{/if}} {{else}} {{asUpperCamelCase name}}AttributeCallback callback {{/if_basic_attribute}} @@ -222,7 +252,11 @@ public class ChipClusters { {{#if isReportableAttribute}} private native void subscribe{{asCamelCased name false}}Attribute(long chipClusterPtr, {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + {{asUpperCamelCase name}}AttributeCallback callback + {{else}} {{as_underlying_java_zcl_type type ../id boolean="Boolean"}}AttributeCallback callback + {{/if}} {{else}} {{asUpperCamelCase name}}AttributeCallback callback {{/if_basic_attribute}}, int minInterval, int maxInterval); diff --git a/src/controller/java/templates/ClusterInfo-java.zapt b/src/controller/java/templates/ClusterInfo-java.zapt index 1c18a3923438ca..025523c59577aa 100644 --- a/src/controller/java/templates/ClusterInfo-java.zapt +++ b/src/controller/java/templates/ClusterInfo-java.zapt @@ -239,6 +239,39 @@ public class ClusterInfoMapping { {{#if_unsupported_attribute_callback type isArray ../id}} {{else}} {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + public static class Delegated{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}AttributeCallback implements ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase name}}AttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + {{! NOTE: asJavaType ends up sniffing for isArray on the context. Since we want the type of our _entry_, force isArray to + false. }} + {{~#*inline "asJavaTypeForEntry"}}{{asJavaType type null parent.name forceNotList=true}}{{/inline~}} + @Override + {{#if isArray}} + public void onSuccess({{#if isNullable}}@Nullable{{/if}} List<{{> asJavaTypeForEntry isArray=false}}> valueList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List<{{> asJavaTypeForEntry isArray=false}}>"); + responseValues.put(commandResponseInfo, valueList); + callback.onSuccess(responseValues); + } + {{else}} + public void onSuccess({{#if isNullable}}@Nullable{{/if}} {{>asJavaTypeForEntry isArray=false}} value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "{{> asJavaTypeForEntry isArray=false}}"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + {{/if}} + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + {{/if}} {{else}} public static class Delegated{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}AttributeCallback implements ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase name}}AttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; diff --git a/src/controller/java/templates/ClusterInfo-read-interaction.zapt b/src/controller/java/templates/ClusterInfo-read-interaction.zapt index 94710e5ce9d7f3..b60c3dac24d0c3 100644 --- a/src/controller/java/templates/ClusterInfo-read-interaction.zapt +++ b/src/controller/java/templates/ClusterInfo-read-interaction.zapt @@ -24,14 +24,22 @@ public class ClusterReadMapping { (cluster, callback, commandArguments) -> { ((ChipClusters.{{asUpperCamelCase ../name}}Cluster) cluster).read{{asUpperCamelCase name}}Attribute( ({{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase name}}AttributeCallback + {{else}} ChipClusters.{{as_underlying_java_zcl_type type ../id boolean="Boolean"}}AttributeCallback + {{/if}} {{else}} ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase name}}AttributeCallback {{/if_basic_attribute}}) callback ); }, {{#if_basic_attribute type ../id}} + {{#if (is_str_equal 'vendor_id' type)}} + () -> new ClusterInfoMapping.Delegated{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}AttributeCallback(), + {{else}} () -> new ClusterInfoMapping.Delegated{{as_underlying_java_zcl_type type ../id boolean="Boolean"}}AttributeCallback(), + {{/if}} {{else}} () -> new ClusterInfoMapping.Delegated{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}AttributeCallback(), {{/if_basic_attribute}} diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index 652f8550370edb..df497ef2dae1ad 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -5283,6 +5283,63 @@ void CHIPActionsAttributeListAttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPBasicInformationVendorIDAttributeCallback::CHIPBasicInformationVendorIDAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPBasicInformationVendorIDAttributeCallback::~CHIPBasicInformationVendorIDAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPBasicInformationVendorIDAttributeCallback::CallbackFn(void * context, chip::VendorId value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + static_cast(value), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + CHIPBasicInformationGeneratedCommandListAttributeCallback::CHIPBasicInformationGeneratedCommandListAttributeCallback( jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), @@ -14287,6 +14344,65 @@ void CHIPEthernetNetworkDiagnosticsAttributeListAttributeCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback::CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback( + jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback::~CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback::CallbackFn(void * context, chip::VendorId value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + static_cast(value), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback:: CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), @@ -30992,6 +31108,63 @@ void CHIPApplicationLauncherAttributeListAttributeCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPApplicationBasicVendorIDAttributeCallback::CHIPApplicationBasicVendorIDAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPApplicationBasicVendorIDAttributeCallback::~CHIPApplicationBasicVendorIDAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPApplicationBasicVendorIDAttributeCallback::CallbackFn(void * context, chip::VendorId value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + static_cast(value), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + CHIPApplicationBasicAllowedVendorListAttributeCallback::CHIPApplicationBasicAllowedVendorListAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), @@ -32541,6 +32714,63 @@ void CHIPUnitTestingListStructOctetStringAttributeCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, arrayListObj); } +CHIPUnitTestingVendorIdAttributeCallback::CHIPUnitTestingVendorIdAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPUnitTestingVendorIdAttributeCallback::~CHIPUnitTestingVendorIdAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPUnitTestingVendorIdAttributeCallback::CallbackFn(void * context, chip::VendorId value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Integer;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + std::string javaValueClassName = "java/lang/Integer"; + std::string javaValueCtorSignature = "(I)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + static_cast(value), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + CHIPUnitTestingListNullablesAndOptionalsStructAttributeCallback::CHIPUnitTestingListNullablesAndOptionalsStructAttributeCallback( jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.h b/src/controller/java/zap-generated/CHIPReadCallbacks.h index ff0eee8cb48e6c..4b7b4759b4af7a 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.h +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.h @@ -2226,6 +2226,36 @@ class CHIPActionsAttributeListAttributeCallback bool keepAlive; }; +class CHIPBasicInformationVendorIDAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPBasicInformationVendorIDAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPBasicInformationVendorIDAttributeCallback(); + + static void maybeDestroy(CHIPBasicInformationVendorIDAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, chip::VendorId value); + static void OnSubscriptionEstablished(void * context, chip::SubscriptionId subscriptionId) + { + CHIP_ERROR err = chip::JniReferences::GetInstance().CallSubscriptionEstablished( + reinterpret_cast(context)->javaCallbackRef, subscriptionId); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error calling onSubscriptionEstablished: %s", ErrorStr(err))); + }; + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPBasicInformationGeneratedCommandListAttributeCallback : public chip::Callback::Callback { @@ -6011,6 +6041,37 @@ class CHIPEthernetNetworkDiagnosticsAttributeListAttributeCallback bool keepAlive; }; +class CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback(); + + static void maybeDestroy(CHIPBridgedDeviceBasicInformationVendorIDAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, chip::VendorId value); + static void OnSubscriptionEstablished(void * context, chip::SubscriptionId subscriptionId) + { + CHIP_ERROR err = chip::JniReferences::GetInstance().CallSubscriptionEstablished( + reinterpret_cast(context)->javaCallbackRef, + subscriptionId); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error calling onSubscriptionEstablished: %s", ErrorStr(err))); + }; + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPBridgedDeviceBasicInformationGeneratedCommandListAttributeCallback : public chip::Callback::Callback { @@ -13149,6 +13210,36 @@ class CHIPApplicationLauncherAttributeListAttributeCallback bool keepAlive; }; +class CHIPApplicationBasicVendorIDAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPApplicationBasicVendorIDAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPApplicationBasicVendorIDAttributeCallback(); + + static void maybeDestroy(CHIPApplicationBasicVendorIDAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, chip::VendorId value); + static void OnSubscriptionEstablished(void * context, chip::SubscriptionId subscriptionId) + { + CHIP_ERROR err = chip::JniReferences::GetInstance().CallSubscriptionEstablished( + reinterpret_cast(context)->javaCallbackRef, subscriptionId); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error calling onSubscriptionEstablished: %s", ErrorStr(err))); + }; + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPApplicationBasicAllowedVendorListAttributeCallback : public chip::Callback::Callback { @@ -13788,6 +13879,36 @@ class CHIPUnitTestingListStructOctetStringAttributeCallback bool keepAlive; }; +class CHIPUnitTestingVendorIdAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPUnitTestingVendorIdAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPUnitTestingVendorIdAttributeCallback(); + + static void maybeDestroy(CHIPUnitTestingVendorIdAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, chip::VendorId value); + static void OnSubscriptionEstablished(void * context, chip::SubscriptionId subscriptionId) + { + CHIP_ERROR err = chip::JniReferences::GetInstance().CallSubscriptionEstablished( + reinterpret_cast(context)->javaCallbackRef, subscriptionId); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error calling onSubscriptionEstablished: %s", ErrorStr(err))); + }; + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPUnitTestingListNullablesAndOptionalsStructAttributeCallback : public chip::Callback::Callback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 68cadaf318e3e4..4e2ba92b3566e3 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -3998,6 +3998,14 @@ public BasicInformationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public interface VendorIDAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { void onSuccess(List valueList); @@ -4048,12 +4056,12 @@ public void subscribeVendorNameAttribute( subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute(IntegerAttributeCallback callback) { + public void readVendorIDAttribute(VendorIDAttributeCallback callback) { readVendorIDAttribute(chipClusterPtr, callback); } public void subscribeVendorIDAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + VendorIDAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } @@ -4298,10 +4306,10 @@ private native void subscribeVendorNameAttribute( int maxInterval); private native void readVendorIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + long chipClusterPtr, VendorIDAttributeCallback callback); private native void subscribeVendorIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); private native void readProductNameAttribute( long chipClusterPtr, CharStringAttributeCallback callback); @@ -10181,6 +10189,14 @@ public BridgedDeviceBasicInformationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public interface VendorIDAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface GeneratedCommandListAttributeCallback { void onSuccess(List valueList); @@ -10222,12 +10238,12 @@ public void subscribeVendorNameAttribute( subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute(IntegerAttributeCallback callback) { + public void readVendorIDAttribute(VendorIDAttributeCallback callback) { readVendorIDAttribute(chipClusterPtr, callback); } public void subscribeVendorIDAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + VendorIDAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } @@ -10421,10 +10437,10 @@ private native void subscribeVendorNameAttribute( int maxInterval); private native void readVendorIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + long chipClusterPtr, VendorIDAttributeCallback callback); private native void subscribeVendorIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); private native void readProductNameAttribute( long chipClusterPtr, CharStringAttributeCallback callback); @@ -24888,6 +24904,14 @@ public ApplicationBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public interface VendorIDAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface AllowedVendorListAttributeCallback { void onSuccess(List valueList); @@ -24937,12 +24961,12 @@ public void subscribeVendorNameAttribute( subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute(IntegerAttributeCallback callback) { + public void readVendorIDAttribute(VendorIDAttributeCallback callback) { readVendorIDAttribute(chipClusterPtr, callback); } public void subscribeVendorIDAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + VendorIDAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } @@ -25055,10 +25079,10 @@ private native void subscribeVendorNameAttribute( int maxInterval); private native void readVendorIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + long chipClusterPtr, VendorIDAttributeCallback callback); private native void subscribeVendorIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); private native void readApplicationNameAttribute( long chipClusterPtr, CharStringAttributeCallback callback); @@ -28196,6 +28220,14 @@ public interface ListStructOctetStringAttributeCallback { default void onSubscriptionEstablished(long subscriptionId) {} } + public interface VendorIdAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished(long subscriptionId) {} + } + public interface ListNullablesAndOptionalsStructAttributeCallback { void onSuccess(List valueList); @@ -29126,7 +29158,7 @@ public void subscribeEpochSAttribute( subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute(IntegerAttributeCallback callback) { + public void readVendorIdAttribute(VendorIdAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } @@ -29140,7 +29172,7 @@ public void writeVendorIdAttribute( } public void subscribeVendorIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + VendorIdAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } @@ -30441,7 +30473,7 @@ private native void subscribeEpochSAttribute( long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); private native void readVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + long chipClusterPtr, VendorIdAttributeCallback callback); private native void writeVendorIdAttribute( long chipClusterPtr, @@ -30450,7 +30482,7 @@ private native void writeVendorIdAttribute( @Nullable Integer timedWriteTimeoutMs); private native void subscribeVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + long chipClusterPtr, VendorIdAttributeCallback callback, int minInterval, int maxInterval); private native void readListNullablesAndOptionalsStructAttribute( long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index e532a920d45eaa..875e2c00a4a256 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -1974,6 +1974,30 @@ public void onError(Exception ex) { } } + public static class DelegatedBasicInformationClusterVendorIDAttributeCallback + implements ChipClusters.BasicInformationCluster.VendorIDAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedBasicInformationClusterGeneratedCommandListAttributeCallback implements ChipClusters.BasicInformationCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback { @@ -5258,6 +5282,30 @@ public void onError(Exception ex) { } } + public static class DelegatedBridgedDeviceBasicInformationClusterVendorIDAttributeCallback + implements ChipClusters.BridgedDeviceBasicInformationCluster.VendorIDAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedBridgedDeviceBasicInformationClusterGeneratedCommandListAttributeCallback implements ChipClusters.BridgedDeviceBasicInformationCluster @@ -11560,6 +11608,30 @@ public void onError(Exception ex) { } } + public static class DelegatedApplicationBasicClusterVendorIDAttributeCallback + implements ChipClusters.ApplicationBasicCluster.VendorIDAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, DelegatedClusterCallback { @@ -12305,6 +12377,30 @@ public void onError(Exception ex) { } } + public static class DelegatedUnitTestingClusterVendorIdAttributeCallback + implements ChipClusters.UnitTestingCluster.VendorIdAttributeCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer"); + responseValues.put(commandResponseInfo, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception ex) { + callback.onFailure(ex); + } + } + public static class DelegatedUnitTestingClusterListNullablesAndOptionalsStructAttributeCallback implements ChipClusters.UnitTestingCluster.ListNullablesAndOptionalsStructAttributeCallback, DelegatedClusterCallback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 59f9942c5c7c51..516d196dd5e122 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -1671,9 +1671,11 @@ public Map> getReadAttributeMap() { new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BasicInformationCluster) cluster) - .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + .readVendorIDAttribute( + (ChipClusters.BasicInformationCluster.VendorIDAttributeCallback) callback); }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + () -> + new ClusterInfoMapping.DelegatedBasicInformationClusterVendorIDAttributeCallback(), readBasicInformationVendorIDCommandParams); readBasicInformationInteractionInfo.put( "readVendorIDAttribute", readBasicInformationVendorIDAttributeInteractionInfo); @@ -5634,9 +5636,13 @@ public Map> getReadAttributeMap() { new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedDeviceBasicInformationCluster) cluster) - .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + .readVendorIDAttribute( + (ChipClusters.BridgedDeviceBasicInformationCluster.VendorIDAttributeCallback) + callback); }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicInformationClusterVendorIDAttributeCallback(), readBridgedDeviceBasicInformationVendorIDCommandParams); readBridgedDeviceBasicInformationInteractionInfo.put( "readVendorIDAttribute", readBridgedDeviceBasicInformationVendorIDAttributeInteractionInfo); @@ -13192,9 +13198,11 @@ public Map> getReadAttributeMap() { new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationBasicCluster) cluster) - .readVendorIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + .readVendorIDAttribute( + (ChipClusters.ApplicationBasicCluster.VendorIDAttributeCallback) callback); }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + () -> + new ClusterInfoMapping.DelegatedApplicationBasicClusterVendorIDAttributeCallback(), readApplicationBasicVendorIDCommandParams); readApplicationBasicInteractionInfo.put( "readVendorIDAttribute", readApplicationBasicVendorIDAttributeInteractionInfo); @@ -15889,9 +15897,10 @@ public Map> getReadAttributeMap() { new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.UnitTestingCluster) cluster) - .readVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + .readVendorIdAttribute( + (ChipClusters.UnitTestingCluster.VendorIdAttributeCallback) callback); }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + () -> new ClusterInfoMapping.DelegatedUnitTestingClusterVendorIdAttributeCallback(), readUnitTestingVendorIdCommandParams); readUnitTestingInteractionInfo.put( "readVendorIdAttribute", readUnitTestingVendorIdAttributeInteractionInfo); diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h index 510d8bd4cc582b..43d54b869a0496 100644 --- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h +++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h @@ -37,22 +37,22 @@ namespace Identify { namespace Attributes { namespace IdentifyTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace IdentifyTime namespace IdentifyType { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace IdentifyType namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -63,17 +63,17 @@ namespace Groups { namespace Attributes { namespace NameSupport { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NameSupport namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -84,44 +84,44 @@ namespace Scenes { namespace Attributes { namespace SceneCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SceneCount namespace CurrentScene { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentScene namespace CurrentGroup { -EmberAfStatus Get(chip::EndpointId endpoint, chip::GroupId * value); // group_id +EmberAfStatus Get(chip::EndpointId endpoint, chip::GroupId * value); // group_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::GroupId value); } // namespace CurrentGroup namespace SceneValid { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace SceneValid namespace NameSupport { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NameSupport namespace LastConfiguredBy { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // node_id +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // node_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::NodeId value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LastConfiguredBy namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -132,28 +132,28 @@ namespace OnOff { namespace Attributes { namespace OnOff { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace OnOff namespace GlobalSceneControl { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace GlobalSceneControl namespace OnTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace OnTime namespace OffWaitTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace OffWaitTime namespace StartUpOnOff { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // OnOffStartUpOnOff + DataModel::Nullable & value); // OnOffStartUpOnOff 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::OnOff::OnOffStartUpOnOff value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -161,12 +161,12 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace StartUpOnOff namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -177,22 +177,22 @@ namespace OnOffSwitchConfiguration { namespace Attributes { namespace SwitchType { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SwitchType namespace SwitchActions { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SwitchActions namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -203,95 +203,95 @@ namespace LevelControl { namespace Attributes { namespace CurrentLevel { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentLevel namespace RemainingTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RemainingTime namespace MinLevel { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MinLevel namespace MaxLevel { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MaxLevel namespace CurrentFrequency { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace CurrentFrequency namespace MinFrequency { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace MinFrequency namespace MaxFrequency { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace MaxFrequency namespace Options { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // LevelControlOptions + chip::BitMask * value); // LevelControlOptions 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Options namespace OnOffTransitionTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace OnOffTransitionTime namespace OnLevel { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OnLevel namespace OnTransitionTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OnTransitionTime namespace OffTransitionTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OffTransitionTime namespace DefaultMoveRate { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace DefaultMoveRate namespace StartUpCurrentLevel { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace StartUpCurrentLevel namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -302,57 +302,57 @@ namespace BinaryInputBasic { namespace Attributes { namespace ActiveText { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ActiveText namespace Description { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace Description namespace InactiveText { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace InactiveText namespace OutOfService { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace OutOfService namespace Polarity { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Polarity namespace PresentValue { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace PresentValue namespace Reliability { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Reliability namespace StatusFlags { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace StatusFlags namespace ApplicationType { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace ApplicationType namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -363,12 +363,12 @@ namespace PulseWidthModulation { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -379,12 +379,12 @@ namespace Descriptor { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -395,12 +395,12 @@ namespace Binding { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -411,27 +411,27 @@ namespace AccessControl { namespace Attributes { namespace SubjectsPerAccessControlEntry { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace SubjectsPerAccessControlEntry namespace TargetsPerAccessControlEntry { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace TargetsPerAccessControlEntry namespace AccessControlEntriesPerFabric { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AccessControlEntriesPerFabric namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -442,17 +442,17 @@ namespace Actions { namespace Attributes { namespace SetupURL { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace SetupURL namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -463,107 +463,107 @@ namespace BasicInformation { namespace Attributes { namespace DataModelRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DataModelRevision namespace VendorName { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace VendorName namespace VendorID { -EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id +EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::VendorId value); } // namespace VendorID namespace ProductName { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ProductName namespace ProductID { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ProductID namespace NodeLabel { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace NodeLabel namespace Location { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace Location namespace HardwareVersion { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace HardwareVersion namespace HardwareVersionString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace HardwareVersionString namespace SoftwareVersion { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace SoftwareVersion namespace SoftwareVersionString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace SoftwareVersionString namespace ManufacturingDate { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ManufacturingDate namespace PartNumber { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace PartNumber namespace ProductURL { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ProductURL namespace ProductLabel { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ProductLabel namespace SerialNumber { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace SerialNumber namespace LocalConfigDisabled { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace LocalConfigDisabled namespace Reachable { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace Reachable namespace UniqueID { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace UniqueID namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -574,12 +574,12 @@ namespace OtaSoftwareUpdateProvider { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -590,30 +590,30 @@ namespace OtaSoftwareUpdateRequestor { namespace Attributes { namespace UpdatePossible { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace UpdatePossible namespace UpdateState { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum * value); // OTAUpdateStateEnum + chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum * value); // OTAUpdateStateEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::OtaSoftwareUpdateRequestor::OTAUpdateStateEnum value); } // namespace UpdateState namespace UpdateStateProgress { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace UpdateStateProgress namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -624,17 +624,17 @@ namespace LocalizationConfiguration { namespace Attributes { namespace ActiveLocale { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ActiveLocale namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -645,23 +645,24 @@ namespace TimeFormatLocalization { namespace Attributes { namespace HourFormat { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum * value); // HourFormatEnum +EmberAfStatus Get(chip::EndpointId endpoint, + chip::app::Clusters::TimeFormatLocalization::HourFormatEnum * value); // HourFormatEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::HourFormatEnum value); } // namespace HourFormat namespace ActiveCalendarType { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum * value); // CalendarTypeEnum + chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum * value); // CalendarTypeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeFormatLocalization::CalendarTypeEnum value); } // namespace ActiveCalendarType namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -672,17 +673,17 @@ namespace UnitLocalization { namespace Attributes { namespace TemperatureUnit { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum * value); // TempUnitEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum * value); // TempUnitEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::UnitLocalization::TempUnitEnum value); } // namespace TemperatureUnit namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -693,12 +694,12 @@ namespace PowerSourceConfiguration { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -710,29 +711,29 @@ namespace Attributes { namespace Status { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PowerSource::PowerSourceStatusEnum * value); // PowerSourceStatusEnum + chip::app::Clusters::PowerSource::PowerSourceStatusEnum * value); // PowerSourceStatusEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::PowerSourceStatusEnum value); } // namespace Status namespace Order { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Order namespace Description { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace Description namespace WiredAssessedInputVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace WiredAssessedInputVoltage namespace WiredAssessedInputFrequency { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -740,142 +741,142 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace WiredCurrentType { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PowerSource::WiredCurrentTypeEnum * value); // WiredCurrentTypeEnum + chip::app::Clusters::PowerSource::WiredCurrentTypeEnum * value); // WiredCurrentTypeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::WiredCurrentTypeEnum value); } // namespace WiredCurrentType namespace WiredAssessedCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace WiredAssessedCurrent namespace WiredNominalVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace WiredNominalVoltage namespace WiredMaximumCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace WiredMaximumCurrent namespace WiredPresent { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace WiredPresent namespace BatVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BatVoltage namespace BatPercentRemaining { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BatPercentRemaining namespace BatTimeRemaining { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BatTimeRemaining namespace BatChargeLevel { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum * value); // BatChargeLevelEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum * value); // BatChargeLevelEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeLevelEnum value); } // namespace BatChargeLevel namespace BatReplacementNeeded { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace BatReplacementNeeded namespace BatReplaceability { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PowerSource::BatReplaceabilityEnum * value); // BatReplaceabilityEnum + chip::app::Clusters::PowerSource::BatReplaceabilityEnum * value); // BatReplaceabilityEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatReplaceabilityEnum value); } // namespace BatReplaceability namespace BatPresent { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace BatPresent namespace BatReplacementDescription { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace BatReplacementDescription namespace BatCommonDesignation { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PowerSource::BatCommonDesignationEnum * value); // BatCommonDesignationEnum + chip::app::Clusters::PowerSource::BatCommonDesignationEnum * value); // BatCommonDesignationEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatCommonDesignationEnum value); } // namespace BatCommonDesignation namespace BatANSIDesignation { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace BatANSIDesignation namespace BatIECDesignation { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace BatIECDesignation namespace BatApprovedChemistry { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PowerSource::BatApprovedChemistryEnum * value); // BatApprovedChemistryEnum + chip::app::Clusters::PowerSource::BatApprovedChemistryEnum * value); // BatApprovedChemistryEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatApprovedChemistryEnum value); } // namespace BatApprovedChemistry namespace BatCapacity { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace BatCapacity namespace BatQuantity { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace BatQuantity namespace BatChargeState { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum * value); // BatChargeStateEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum * value); // BatChargeStateEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PowerSource::BatChargeStateEnum value); } // namespace BatChargeState namespace BatTimeToFullCharge { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BatTimeToFullCharge namespace BatFunctionalWhileCharging { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace BatFunctionalWhileCharging namespace BatChargingCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BatChargingCurrent namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -886,34 +887,34 @@ namespace GeneralCommissioning { namespace Attributes { namespace Breadcrumb { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace Breadcrumb namespace RegulatoryConfig { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType * value); // RegulatoryLocationType + chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType * value); // RegulatoryLocationType 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType value); } // namespace RegulatoryConfig namespace LocationCapability { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType * value); // RegulatoryLocationType + chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType * value); // RegulatoryLocationType 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::GeneralCommissioning::RegulatoryLocationType value); } // namespace LocationCapability namespace SupportsConcurrentConnection { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace SupportsConcurrentConnection namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -924,29 +925,29 @@ namespace NetworkCommissioning { namespace Attributes { namespace MaxNetworks { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MaxNetworks namespace ScanMaxTimeSeconds { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ScanMaxTimeSeconds namespace ConnectMaxTimeSeconds { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ConnectMaxTimeSeconds namespace InterfaceEnabled { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace InterfaceEnabled namespace LastNetworkingStatus { EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & - value); // NetworkCommissioningStatus + value); // NetworkCommissioningStatus 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::NetworkCommissioning::NetworkCommissioningStatus value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus @@ -955,26 +956,26 @@ Set(chip::EndpointId endpoint, } // namespace LastNetworkingStatus namespace LastNetworkID { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LastNetworkID namespace LastConnectErrorValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LastConnectErrorValue namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -985,12 +986,12 @@ namespace DiagnosticLogs { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1001,37 +1002,37 @@ namespace GeneralDiagnostics { namespace Attributes { namespace RebootCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RebootCount namespace UpTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace UpTime namespace TotalOperationalHours { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TotalOperationalHours namespace BootReason { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::GeneralDiagnostics::BootReasonEnum * value); // BootReasonEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::GeneralDiagnostics::BootReasonEnum * value); // BootReasonEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::GeneralDiagnostics::BootReasonEnum value); } // namespace BootReason namespace TestEventTriggersEnabled { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace TestEventTriggersEnabled namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1042,27 +1043,27 @@ namespace SoftwareDiagnostics { namespace Attributes { namespace CurrentHeapFree { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace CurrentHeapFree namespace CurrentHeapUsed { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace CurrentHeapUsed namespace CurrentHeapHighWatermark { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace CurrentHeapHighWatermark namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1073,7 +1074,7 @@ namespace ThreadNetworkDiagnostics { namespace Attributes { namespace Channel { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -1081,7 +1082,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace RoutingRole { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // RoutingRole + DataModel::Nullable & value); // RoutingRole 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ThreadNetworkDiagnostics::RoutingRole value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -1089,318 +1090,318 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace RoutingRole namespace NetworkName { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NetworkName namespace PanId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PanId namespace ExtendedPanId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ExtendedPanId namespace MeshLocalPrefix { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MeshLocalPrefix namespace OverrunCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace OverrunCount namespace PartitionId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PartitionId namespace Weighting { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Weighting namespace DataVersion { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace DataVersion namespace StableDataVersion { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace StableDataVersion namespace LeaderRouterId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LeaderRouterId namespace DetachedRoleCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DetachedRoleCount namespace ChildRoleCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ChildRoleCount namespace RouterRoleCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RouterRoleCount namespace LeaderRoleCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace LeaderRoleCount namespace AttachAttemptCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AttachAttemptCount namespace PartitionIdChangeCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PartitionIdChangeCount namespace BetterPartitionAttachAttemptCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BetterPartitionAttachAttemptCount namespace ParentChangeCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ParentChangeCount namespace TxTotalCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxTotalCount namespace TxUnicastCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxUnicastCount namespace TxBroadcastCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxBroadcastCount namespace TxAckRequestedCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxAckRequestedCount namespace TxAckedCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxAckedCount namespace TxNoAckRequestedCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxNoAckRequestedCount namespace TxDataCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxDataCount namespace TxDataPollCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxDataPollCount namespace TxBeaconCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxBeaconCount namespace TxBeaconRequestCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxBeaconRequestCount namespace TxOtherCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxOtherCount namespace TxRetryCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxRetryCount namespace TxDirectMaxRetryExpiryCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxDirectMaxRetryExpiryCount namespace TxIndirectMaxRetryExpiryCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxIndirectMaxRetryExpiryCount namespace TxErrCcaCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxErrCcaCount namespace TxErrAbortCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxErrAbortCount namespace TxErrBusyChannelCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TxErrBusyChannelCount namespace RxTotalCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxTotalCount namespace RxUnicastCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxUnicastCount namespace RxBroadcastCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxBroadcastCount namespace RxDataCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxDataCount namespace RxDataPollCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxDataPollCount namespace RxBeaconCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxBeaconCount namespace RxBeaconRequestCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxBeaconRequestCount namespace RxOtherCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxOtherCount namespace RxAddressFilteredCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxAddressFilteredCount namespace RxDestAddrFilteredCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxDestAddrFilteredCount namespace RxDuplicatedCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxDuplicatedCount namespace RxErrNoFrameCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxErrNoFrameCount namespace RxErrUnknownNeighborCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxErrUnknownNeighborCount namespace RxErrInvalidSrcAddrCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxErrInvalidSrcAddrCount namespace RxErrSecCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxErrSecCount namespace RxErrFcsCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxErrFcsCount namespace RxErrOtherCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace RxErrOtherCount namespace ActiveTimestamp { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ActiveTimestamp namespace PendingTimestamp { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PendingTimestamp namespace Delay { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Delay namespace ChannelPage0Mask { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ChannelPage0Mask namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1411,7 +1412,7 @@ namespace WiFiNetworkDiagnostics { namespace Attributes { namespace Bssid { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -1419,7 +1420,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace SecurityType { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // SecurityTypeEnum + DataModel::Nullable & value); // SecurityTypeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::WiFiNetworkDiagnostics::SecurityTypeEnum value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -1428,7 +1429,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, namespace WiFiVersion { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // WiFiVersionEnum + DataModel::Nullable & value); // WiFiVersionEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -1436,82 +1437,82 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace WiFiVersion namespace ChannelNumber { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ChannelNumber namespace Rssi { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Rssi namespace BeaconLostCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BeaconLostCount namespace BeaconRxCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BeaconRxCount namespace PacketMulticastRxCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PacketMulticastRxCount namespace PacketMulticastTxCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PacketMulticastTxCount namespace PacketUnicastRxCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PacketUnicastRxCount namespace PacketUnicastTxCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PacketUnicastTxCount namespace CurrentMaxRate { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentMaxRate namespace OverrunCount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OverrunCount namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1523,7 +1524,7 @@ namespace Attributes { namespace PHYRate { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // PHYRateEnum + DataModel::Nullable & value); // PHYRateEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::EthernetNetworkDiagnostics::PHYRateEnum value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -1531,56 +1532,56 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace PHYRate namespace FullDuplex { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace FullDuplex namespace PacketRxCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace PacketRxCount namespace PacketTxCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace PacketTxCount namespace TxErrCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace TxErrCount namespace CollisionCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace CollisionCount namespace OverrunCount { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace OverrunCount namespace CarrierDetect { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CarrierDetect namespace TimeSinceReset { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace TimeSinceReset namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1591,62 +1592,63 @@ namespace TimeSynchronization { namespace Attributes { namespace UTCTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace UTCTime namespace Granularity { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::GranularityEnum * value); // GranularityEnum +EmberAfStatus Get(chip::EndpointId endpoint, + chip::app::Clusters::TimeSynchronization::GranularityEnum * value); // GranularityEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::GranularityEnum value); } // namespace Granularity namespace TimeSource { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum * value); // TimeSourceEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum * value); // TimeSourceEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::TimeSynchronization::TimeSourceEnum value); } // namespace TimeSource namespace TrustedTimeNodeId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // node_id +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // node_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::NodeId value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace TrustedTimeNodeId namespace DefaultNtp { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace DefaultNtp namespace LocalTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LocalTime namespace TimeZoneDatabase { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace TimeZoneDatabase namespace NtpServerPort { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NtpServerPort namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1657,87 +1659,87 @@ namespace BridgedDeviceBasicInformation { namespace Attributes { namespace VendorName { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace VendorName namespace VendorID { -EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id +EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::VendorId value); } // namespace VendorID namespace ProductName { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ProductName namespace NodeLabel { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace NodeLabel namespace HardwareVersion { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace HardwareVersion namespace HardwareVersionString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace HardwareVersionString namespace SoftwareVersion { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace SoftwareVersion namespace SoftwareVersionString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace SoftwareVersionString namespace ManufacturingDate { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ManufacturingDate namespace PartNumber { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace PartNumber namespace ProductURL { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ProductURL namespace ProductLabel { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ProductLabel namespace SerialNumber { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace SerialNumber namespace Reachable { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace Reachable namespace UniqueID { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace UniqueID namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1748,27 +1750,27 @@ namespace Switch { namespace Attributes { namespace NumberOfPositions { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfPositions namespace CurrentPosition { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentPosition namespace MultiPressMax { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MultiPressMax namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1781,31 +1783,31 @@ namespace Attributes { namespace WindowStatus { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum * value); // CommissioningWindowStatusEnum + chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum * value); // CommissioningWindowStatusEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::AdministratorCommissioning::CommissioningWindowStatusEnum value); } // namespace WindowStatus namespace AdminFabricIndex { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // fabric_idx +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // fabric_idx 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::FabricIndex value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace AdminFabricIndex namespace AdminVendorId { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace AdminVendorId namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1816,27 +1818,27 @@ namespace OperationalCredentials { namespace Attributes { namespace SupportedFabrics { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SupportedFabrics namespace CommissionedFabrics { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CommissionedFabrics namespace CurrentFabricIndex { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentFabricIndex namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1847,22 +1849,22 @@ namespace GroupKeyManagement { namespace Attributes { namespace MaxGroupsPerFabric { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace MaxGroupsPerFabric namespace MaxGroupKeysPerFabric { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace MaxGroupKeysPerFabric namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1873,12 +1875,12 @@ namespace FixedLabel { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1889,12 +1891,12 @@ namespace UserLabel { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1905,12 +1907,12 @@ namespace ProxyConfiguration { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1921,12 +1923,12 @@ namespace ProxyDiscovery { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1937,12 +1939,12 @@ namespace ProxyValid { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1953,17 +1955,17 @@ namespace BooleanState { namespace Attributes { namespace StateValue { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace StateValue namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -1974,43 +1976,43 @@ namespace ModeSelect { namespace Attributes { namespace Description { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace Description namespace StandardNamespace { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum16 +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace StandardNamespace namespace CurrentMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentMode namespace StartUpMode { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace StartUpMode namespace OnMode { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OnMode namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2022,7 +2024,7 @@ namespace Attributes { namespace LockState { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // DlLockState + DataModel::Nullable & value); // DlLockState 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockState value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -2030,18 +2032,18 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace LockState namespace LockType { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType * value); // DlLockType +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType * value); // DlLockType 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::DlLockType value); } // namespace LockType namespace ActuatorEnabled { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace ActuatorEnabled namespace DoorState { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // DoorStateEnum + DataModel::Nullable & value); // DoorStateEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::DoorStateEnum value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -2049,177 +2051,177 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace DoorState namespace DoorOpenEvents { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace DoorOpenEvents namespace DoorClosedEvents { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace DoorClosedEvents namespace OpenPeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace OpenPeriod namespace NumberOfTotalUsersSupported { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace NumberOfTotalUsersSupported namespace NumberOfPINUsersSupported { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace NumberOfPINUsersSupported namespace NumberOfRFIDUsersSupported { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace NumberOfRFIDUsersSupported namespace NumberOfWeekDaySchedulesSupportedPerUser { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfWeekDaySchedulesSupportedPerUser namespace NumberOfYearDaySchedulesSupportedPerUser { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfYearDaySchedulesSupportedPerUser namespace NumberOfHolidaySchedulesSupported { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfHolidaySchedulesSupported namespace MaxPINCodeLength { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MaxPINCodeLength namespace MinPINCodeLength { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MinPINCodeLength namespace MaxRFIDCodeLength { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MaxRFIDCodeLength namespace MinRFIDCodeLength { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MinRFIDCodeLength namespace CredentialRulesSupport { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // DlCredentialRuleMask + chip::BitMask * value); // DlCredentialRuleMask 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace CredentialRulesSupport namespace NumberOfCredentialsSupportedPerUser { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfCredentialsSupportedPerUser namespace Language { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace Language namespace LEDSettings { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace LEDSettings namespace AutoRelockTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace AutoRelockTime namespace SoundVolume { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SoundVolume namespace OperatingMode { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum * value); // OperatingModeEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum * value); // OperatingModeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::DoorLock::OperatingModeEnum value); } // namespace OperatingMode namespace SupportedOperatingModes { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // DlSupportedOperatingModes + chip::BitMask * value); // DlSupportedOperatingModes 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace SupportedOperatingModes namespace DefaultConfigurationRegister { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // DlDefaultConfigurationRegister + chip::BitMask * value); // DlDefaultConfigurationRegister 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace DefaultConfigurationRegister namespace EnableLocalProgramming { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace EnableLocalProgramming namespace EnableOneTouchLocking { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace EnableOneTouchLocking namespace EnableInsideStatusLED { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace EnableInsideStatusLED namespace EnablePrivacyModeButton { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace EnablePrivacyModeButton namespace LocalProgrammingFeatures { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // DlLocalProgrammingFeatures + chip::BitMask * value); // DlLocalProgrammingFeatures 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace LocalProgrammingFeatures namespace WrongCodeEntryLimit { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace WrongCodeEntryLimit namespace UserCodeTemporaryDisableTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace UserCodeTemporaryDisableTime namespace SendPINOverTheAir { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace SendPINOverTheAir namespace RequirePINforRemoteOperation { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace RequirePINforRemoteOperation namespace ExpiringUserTimeout { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ExpiringUserTimeout namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2230,59 +2232,59 @@ namespace WindowCovering { namespace Attributes { namespace Type { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::WindowCovering::Type * value); // Type +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::WindowCovering::Type * value); // Type 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::WindowCovering::Type value); } // namespace Type namespace PhysicalClosedLimitLift { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PhysicalClosedLimitLift namespace PhysicalClosedLimitTilt { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PhysicalClosedLimitTilt namespace CurrentPositionLift { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentPositionLift namespace CurrentPositionTilt { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentPositionTilt namespace NumberOfActuationsLift { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace NumberOfActuationsLift namespace NumberOfActuationsTilt { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace NumberOfActuationsTilt namespace ConfigStatus { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // ConfigStatus + chip::BitMask * value); // ConfigStatus 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace ConfigStatus namespace CurrentPositionLiftPercentage { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentPositionLiftPercentage namespace CurrentPositionTiltPercentage { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -2290,81 +2292,81 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace OperationalStatus { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // OperationalStatus + chip::BitMask * value); // OperationalStatus 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace OperationalStatus namespace TargetPositionLiftPercent100ths { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent100ths value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace TargetPositionLiftPercent100ths namespace TargetPositionTiltPercent100ths { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent100ths value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace TargetPositionTiltPercent100ths namespace EndProductType { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType * value); // EndProductType +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType * value); // EndProductType 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::WindowCovering::EndProductType value); } // namespace EndProductType namespace CurrentPositionLiftPercent100ths { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent100ths value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentPositionLiftPercent100ths namespace CurrentPositionTiltPercent100ths { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // Percent100ths 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::Percent100ths value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace CurrentPositionTiltPercent100ths namespace InstalledOpenLimitLift { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace InstalledOpenLimitLift namespace InstalledClosedLimitLift { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace InstalledClosedLimitLift namespace InstalledOpenLimitTilt { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace InstalledOpenLimitTilt namespace InstalledClosedLimitTilt { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace InstalledClosedLimitTilt namespace Mode { -EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value); // Mode +EmberAfStatus Get(chip::EndpointId endpoint, chip::BitMask * value); // Mode 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Mode namespace SafetyStatus { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // SafetyStatus + chip::BitMask * value); // SafetyStatus 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace SafetyStatus namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2375,62 +2377,62 @@ namespace BarrierControl { namespace Attributes { namespace BarrierMovingState { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace BarrierMovingState namespace BarrierSafetyStatus { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierSafetyStatus namespace BarrierCapabilities { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace BarrierCapabilities namespace BarrierOpenEvents { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierOpenEvents namespace BarrierCloseEvents { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierCloseEvents namespace BarrierCommandOpenEvents { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierCommandOpenEvents namespace BarrierCommandCloseEvents { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierCommandCloseEvents namespace BarrierOpenPeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierOpenPeriod namespace BarrierClosePeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace BarrierClosePeriod namespace BarrierPosition { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace BarrierPosition namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2441,91 +2443,91 @@ namespace PumpConfigurationAndControl { namespace Attributes { namespace MaxPressure { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxPressure namespace MaxSpeed { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxSpeed namespace MaxFlow { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxFlow namespace MinConstPressure { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinConstPressure namespace MaxConstPressure { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxConstPressure namespace MinCompPressure { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinCompPressure namespace MaxCompPressure { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxCompPressure namespace MinConstSpeed { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinConstSpeed namespace MaxConstSpeed { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxConstSpeed namespace MinConstFlow { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinConstFlow namespace MaxConstFlow { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxConstFlow namespace MinConstTemp { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinConstTemp namespace MaxConstTemp { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -2533,53 +2535,53 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace PumpStatus { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // PumpStatusBitmap + chip::BitMask * value); // PumpStatusBitmap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace PumpStatus namespace EffectiveOperationMode { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value); // OperationModeEnum + chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value); // OperationModeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value); } // namespace EffectiveOperationMode namespace EffectiveControlMode { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value); // ControlModeEnum + chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value); // ControlModeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value); } // namespace EffectiveControlMode namespace Capacity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Capacity namespace Speed { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Speed namespace LifetimeRunningHours { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LifetimeRunningHours namespace Power { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Power namespace LifetimeEnergyConsumed { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -2587,23 +2589,23 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace OperationMode { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value); // OperationModeEnum + chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum * value); // OperationModeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::OperationModeEnum value); } // namespace OperationMode namespace ControlMode { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value); // ControlModeEnum + chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum * value); // ControlModeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::PumpConfigurationAndControl::ControlModeEnum value); } // namespace ControlMode namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2614,280 +2616,280 @@ namespace Thermostat { namespace Attributes { namespace LocalTemperature { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LocalTemperature namespace OutdoorTemperature { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OutdoorTemperature namespace Occupancy { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Occupancy namespace AbsMinHeatSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AbsMinHeatSetpointLimit namespace AbsMaxHeatSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AbsMaxHeatSetpointLimit namespace AbsMinCoolSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AbsMinCoolSetpointLimit namespace AbsMaxCoolSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AbsMaxCoolSetpointLimit namespace PICoolingDemand { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PICoolingDemand namespace PIHeatingDemand { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PIHeatingDemand namespace HVACSystemTypeConfiguration { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace HVACSystemTypeConfiguration namespace LocalTemperatureCalibration { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace LocalTemperatureCalibration namespace OccupiedCoolingSetpoint { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace OccupiedCoolingSetpoint namespace OccupiedHeatingSetpoint { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace OccupiedHeatingSetpoint namespace UnoccupiedCoolingSetpoint { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace UnoccupiedCoolingSetpoint namespace UnoccupiedHeatingSetpoint { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace UnoccupiedHeatingSetpoint namespace MinHeatSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MinHeatSetpointLimit namespace MaxHeatSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MaxHeatSetpointLimit namespace MinCoolSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MinCoolSetpointLimit namespace MaxCoolSetpointLimit { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MaxCoolSetpointLimit namespace MinSetpointDeadBand { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace MinSetpointDeadBand namespace RemoteSensing { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace RemoteSensing namespace ControlSequenceOfOperation { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::Thermostat::ThermostatControlSequence * value); // ThermostatControlSequence + chip::app::Clusters::Thermostat::ThermostatControlSequence * value); // ThermostatControlSequence 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::Thermostat::ThermostatControlSequence value); } // namespace ControlSequenceOfOperation namespace SystemMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SystemMode namespace ThermostatRunningMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ThermostatRunningMode namespace StartOfWeek { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace StartOfWeek namespace NumberOfWeeklyTransitions { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfWeeklyTransitions namespace NumberOfDailyTransitions { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace NumberOfDailyTransitions namespace TemperatureSetpointHold { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace TemperatureSetpointHold namespace TemperatureSetpointHoldDuration { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace TemperatureSetpointHoldDuration namespace ThermostatProgrammingOperationMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ThermostatProgrammingOperationMode namespace ThermostatRunningState { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ThermostatRunningState namespace SetpointChangeSource { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SetpointChangeSource namespace SetpointChangeAmount { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace SetpointChangeAmount namespace SetpointChangeSourceTimestamp { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // epoch_s +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // epoch_s 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace SetpointChangeSourceTimestamp namespace OccupiedSetback { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OccupiedSetback namespace OccupiedSetbackMin { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OccupiedSetbackMin namespace OccupiedSetbackMax { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace OccupiedSetbackMax namespace UnoccupiedSetback { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace UnoccupiedSetback namespace UnoccupiedSetbackMin { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace UnoccupiedSetbackMin namespace UnoccupiedSetbackMax { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace UnoccupiedSetbackMax namespace EmergencyHeatDelta { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace EmergencyHeatDelta namespace ACType { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ACType namespace ACCapacity { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ACCapacity namespace ACRefrigerantType { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ACRefrigerantType namespace ACCompressorType { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ACCompressorType namespace ACErrorCode { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace ACErrorCode namespace ACLouverPosition { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ACLouverPosition namespace ACCoilTemperature { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ACCoilTemperature namespace ACCapacityformat { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ACCapacityformat namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2898,71 +2900,71 @@ namespace FanControl { namespace Attributes { namespace FanMode { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::FanControl::FanModeType * value); // FanModeType +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::FanControl::FanModeType * value); // FanModeType 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::FanControl::FanModeType value); } // namespace FanMode namespace FanModeSequence { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceType * value); // FanModeSequenceType +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceType * value); // FanModeSequenceType 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::FanControl::FanModeSequenceType value); } // namespace FanModeSequence namespace PercentSetting { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace PercentSetting namespace PercentCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PercentCurrent namespace SpeedMax { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SpeedMax namespace SpeedSetting { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace SpeedSetting namespace SpeedCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace SpeedCurrent namespace RockSupport { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace RockSupport namespace RockSetting { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace RockSetting namespace WindSupport { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace WindSupport namespace WindSetting { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace WindSetting namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -2973,27 +2975,27 @@ namespace ThermostatUserInterfaceConfiguration { namespace Attributes { namespace TemperatureDisplayMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace TemperatureDisplayMode namespace KeypadLockout { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace KeypadLockout namespace ScheduleProgrammingVisibility { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ScheduleProgrammingVisibility namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3004,294 +3006,294 @@ namespace ColorControl { namespace Attributes { namespace CurrentHue { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentHue namespace CurrentSaturation { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentSaturation namespace RemainingTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RemainingTime namespace CurrentX { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace CurrentX namespace CurrentY { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace CurrentY namespace DriftCompensation { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace DriftCompensation namespace CompensationText { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace CompensationText namespace ColorTemperatureMireds { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorTemperatureMireds namespace ColorMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ColorMode namespace Options { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Options namespace NumberOfPrimaries { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NumberOfPrimaries namespace Primary1X { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary1X namespace Primary1Y { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary1Y namespace Primary1Intensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Primary1Intensity namespace Primary2X { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary2X namespace Primary2Y { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary2Y namespace Primary2Intensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Primary2Intensity namespace Primary3X { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary3X namespace Primary3Y { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary3Y namespace Primary3Intensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Primary3Intensity namespace Primary4X { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary4X namespace Primary4Y { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary4Y namespace Primary4Intensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Primary4Intensity namespace Primary5X { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary5X namespace Primary5Y { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary5Y namespace Primary5Intensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Primary5Intensity namespace Primary6X { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary6X namespace Primary6Y { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Primary6Y namespace Primary6Intensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Primary6Intensity namespace WhitePointX { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace WhitePointX namespace WhitePointY { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace WhitePointY namespace ColorPointRX { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorPointRX namespace ColorPointRY { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorPointRY namespace ColorPointRIntensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ColorPointRIntensity namespace ColorPointGX { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorPointGX namespace ColorPointGY { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorPointGY namespace ColorPointGIntensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ColorPointGIntensity namespace ColorPointBX { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorPointBX namespace ColorPointBY { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorPointBY namespace ColorPointBIntensity { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ColorPointBIntensity namespace EnhancedCurrentHue { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace EnhancedCurrentHue namespace EnhancedColorMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace EnhancedColorMode namespace ColorLoopActive { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ColorLoopActive namespace ColorLoopDirection { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace ColorLoopDirection namespace ColorLoopTime { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorLoopTime namespace ColorLoopStartEnhancedHue { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorLoopStartEnhancedHue namespace ColorLoopStoredEnhancedHue { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorLoopStoredEnhancedHue namespace ColorCapabilities { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorCapabilities namespace ColorTempPhysicalMinMireds { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorTempPhysicalMinMireds namespace ColorTempPhysicalMaxMireds { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ColorTempPhysicalMaxMireds namespace CoupleColorTempToLevelMinMireds { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace CoupleColorTempToLevelMinMireds namespace StartUpColorTemperatureMireds { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace StartUpColorTemperatureMireds namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3302,92 +3304,92 @@ namespace BallastConfiguration { namespace Attributes { namespace PhysicalMinLevel { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PhysicalMinLevel namespace PhysicalMaxLevel { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PhysicalMaxLevel namespace BallastStatus { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace BallastStatus namespace MinLevel { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MinLevel namespace MaxLevel { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace MaxLevel namespace IntrinsicBallastFactor { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace IntrinsicBallastFactor namespace BallastFactorAdjustment { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace BallastFactorAdjustment namespace LampQuantity { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace LampQuantity namespace LampType { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace LampType namespace LampManufacturer { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace LampManufacturer namespace LampRatedHours { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LampRatedHours namespace LampBurnHours { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LampBurnHours namespace LampAlarmMode { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace LampAlarmMode namespace LampBurnHoursTripPoint { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LampBurnHoursTripPoint namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3398,45 +3400,45 @@ namespace IlluminanceMeasurement { namespace Attributes { namespace MeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MeasuredValue namespace MinMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinMeasuredValue namespace MaxMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxMeasuredValue namespace Tolerance { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Tolerance namespace LightSensorType { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace LightSensorType namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3447,38 +3449,38 @@ namespace TemperatureMeasurement { namespace Attributes { namespace MeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MeasuredValue namespace MinMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinMeasuredValue namespace MaxMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxMeasuredValue namespace Tolerance { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Tolerance namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3489,69 +3491,69 @@ namespace PressureMeasurement { namespace Attributes { namespace MeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MeasuredValue namespace MinMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinMeasuredValue namespace MaxMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxMeasuredValue namespace Tolerance { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Tolerance namespace ScaledValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace ScaledValue namespace MinScaledValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinScaledValue namespace MaxScaledValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxScaledValue namespace ScaledTolerance { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ScaledTolerance namespace Scale { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace Scale namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3562,38 +3564,38 @@ namespace FlowMeasurement { namespace Attributes { namespace MeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MeasuredValue namespace MinMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinMeasuredValue namespace MaxMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxMeasuredValue namespace Tolerance { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Tolerance namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3604,38 +3606,38 @@ namespace RelativeHumidityMeasurement { namespace Attributes { namespace MeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MeasuredValue namespace MinMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MinMeasuredValue namespace MaxMeasuredValue { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace MaxMeasuredValue namespace Tolerance { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Tolerance namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3647,75 +3649,75 @@ namespace Attributes { namespace Occupancy { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // OccupancyBitmap + chip::BitMask * value); // OccupancyBitmap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Occupancy namespace OccupancySensorType { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum * value); // OccupancySensorTypeEnum + chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum * value); // OccupancySensorTypeEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::OccupancySensing::OccupancySensorTypeEnum value); } // namespace OccupancySensorType namespace OccupancySensorTypeBitmap { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // OccupancySensorTypeBitmap + chip::BitMask * value); // OccupancySensorTypeBitmap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace OccupancySensorTypeBitmap namespace PIROccupiedToUnoccupiedDelay { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PIROccupiedToUnoccupiedDelay namespace PIRUnoccupiedToOccupiedDelay { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PIRUnoccupiedToOccupiedDelay namespace PIRUnoccupiedToOccupiedThreshold { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PIRUnoccupiedToOccupiedThreshold namespace UltrasonicOccupiedToUnoccupiedDelay { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace UltrasonicOccupiedToUnoccupiedDelay namespace UltrasonicUnoccupiedToOccupiedDelay { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace UltrasonicUnoccupiedToOccupiedDelay namespace UltrasonicUnoccupiedToOccupiedThreshold { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace UltrasonicUnoccupiedToOccupiedThreshold namespace PhysicalContactOccupiedToUnoccupiedDelay { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PhysicalContactOccupiedToUnoccupiedDelay namespace PhysicalContactUnoccupiedToOccupiedDelay { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace PhysicalContactUnoccupiedToOccupiedDelay namespace PhysicalContactUnoccupiedToOccupiedThreshold { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace PhysicalContactUnoccupiedToOccupiedThreshold namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3726,17 +3728,17 @@ namespace WakeOnLan { namespace Attributes { namespace MACAddress { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace MACAddress namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3747,12 +3749,12 @@ namespace Channel { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3763,17 +3765,17 @@ namespace TargetNavigator { namespace Attributes { namespace CurrentTarget { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentTarget namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3784,50 +3786,50 @@ namespace MediaPlayback { namespace Attributes { namespace CurrentState { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum * value); // PlaybackStateEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum * value); // PlaybackStateEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::MediaPlayback::PlaybackStateEnum value); } // namespace CurrentState namespace StartTime { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // epoch_us 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace StartTime namespace Duration { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace Duration namespace PlaybackSpeed { -EmberAfStatus Get(chip::EndpointId endpoint, float * value); // single +EmberAfStatus Get(chip::EndpointId endpoint, float * value); // single 0 EmberAfStatus Set(chip::EndpointId endpoint, float value); } // namespace PlaybackSpeed namespace SeekRangeEnd { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace SeekRangeEnd namespace SeekRangeStart { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace SeekRangeStart namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3838,17 +3840,17 @@ namespace MediaInput { namespace Attributes { namespace CurrentInput { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentInput namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3859,12 +3861,12 @@ namespace LowPower { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3875,12 +3877,12 @@ namespace KeypadInput { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3891,17 +3893,17 @@ namespace ContentLauncher { namespace Attributes { namespace SupportedStreamingProtocols { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace SupportedStreamingProtocols namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3912,17 +3914,17 @@ namespace AudioOutput { namespace Attributes { namespace CurrentOutput { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace CurrentOutput namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3933,12 +3935,12 @@ namespace ApplicationLauncher { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3949,43 +3951,43 @@ namespace ApplicationBasic { namespace Attributes { namespace VendorName { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace VendorName namespace VendorID { -EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id +EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::VendorId value); } // namespace VendorID namespace ApplicationName { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ApplicationName namespace ProductID { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ProductID namespace Status { EmberAfStatus Get(chip::EndpointId endpoint, - chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum * value); // ApplicationStatusEnum + chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum * value); // ApplicationStatusEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::ApplicationBasic::ApplicationStatusEnum value); } // namespace Status namespace ApplicationVersion { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace ApplicationVersion namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -3996,12 +3998,12 @@ namespace AccountLogin { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -4012,652 +4014,652 @@ namespace ElectricalMeasurement { namespace Attributes { namespace MeasurementType { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace MeasurementType namespace DcVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcVoltage namespace DcVoltageMin { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcVoltageMin namespace DcVoltageMax { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcVoltageMax namespace DcCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcCurrent namespace DcCurrentMin { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcCurrentMin namespace DcCurrentMax { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcCurrentMax namespace DcPower { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcPower namespace DcPowerMin { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcPowerMin namespace DcPowerMax { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace DcPowerMax namespace DcVoltageMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DcVoltageMultiplier namespace DcVoltageDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DcVoltageDivisor namespace DcCurrentMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DcCurrentMultiplier namespace DcCurrentDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DcCurrentDivisor namespace DcPowerMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DcPowerMultiplier namespace DcPowerDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace DcPowerDivisor namespace AcFrequency { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcFrequency namespace AcFrequencyMin { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcFrequencyMin namespace AcFrequencyMax { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcFrequencyMax namespace NeutralCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace NeutralCurrent namespace TotalActivePower { -EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int32s +EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int32s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); } // namespace TotalActivePower namespace TotalReactivePower { -EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int32s +EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int32s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); } // namespace TotalReactivePower namespace TotalApparentPower { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace TotalApparentPower namespace Measured1stHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Measured1stHarmonicCurrent namespace Measured3rdHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Measured3rdHarmonicCurrent namespace Measured5thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Measured5thHarmonicCurrent namespace Measured7thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Measured7thHarmonicCurrent namespace Measured9thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Measured9thHarmonicCurrent namespace Measured11thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Measured11thHarmonicCurrent namespace MeasuredPhase1stHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MeasuredPhase1stHarmonicCurrent namespace MeasuredPhase3rdHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MeasuredPhase3rdHarmonicCurrent namespace MeasuredPhase5thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MeasuredPhase5thHarmonicCurrent namespace MeasuredPhase7thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MeasuredPhase7thHarmonicCurrent namespace MeasuredPhase9thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MeasuredPhase9thHarmonicCurrent namespace MeasuredPhase11thHarmonicCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace MeasuredPhase11thHarmonicCurrent namespace AcFrequencyMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcFrequencyMultiplier namespace AcFrequencyDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcFrequencyDivisor namespace PowerMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace PowerMultiplier namespace PowerDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace PowerDivisor namespace HarmonicCurrentMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace HarmonicCurrentMultiplier namespace PhaseHarmonicCurrentMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace PhaseHarmonicCurrentMultiplier namespace InstantaneousVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace InstantaneousVoltage namespace InstantaneousLineCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace InstantaneousLineCurrent namespace InstantaneousActiveCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace InstantaneousActiveCurrent namespace InstantaneousReactiveCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace InstantaneousReactiveCurrent namespace InstantaneousPower { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace InstantaneousPower namespace RmsVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltage namespace RmsVoltageMin { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageMin namespace RmsVoltageMax { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageMax namespace RmsCurrent { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrent namespace RmsCurrentMin { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentMin namespace RmsCurrentMax { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentMax namespace ActivePower { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePower namespace ActivePowerMin { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerMin namespace ActivePowerMax { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerMax namespace ReactivePower { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ReactivePower namespace ApparentPower { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ApparentPower namespace PowerFactor { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace PowerFactor namespace AverageRmsVoltageMeasurementPeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsVoltageMeasurementPeriod namespace AverageRmsUnderVoltageCounter { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsUnderVoltageCounter namespace RmsExtremeOverVoltagePeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsExtremeOverVoltagePeriod namespace RmsExtremeUnderVoltagePeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsExtremeUnderVoltagePeriod namespace RmsVoltageSagPeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageSagPeriod namespace RmsVoltageSwellPeriod { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageSwellPeriod namespace AcVoltageMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcVoltageMultiplier namespace AcVoltageDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcVoltageDivisor namespace AcCurrentMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcCurrentMultiplier namespace AcCurrentDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcCurrentDivisor namespace AcPowerMultiplier { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcPowerMultiplier namespace AcPowerDivisor { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcPowerDivisor namespace OverloadAlarmsMask { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // bitmap8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace OverloadAlarmsMask namespace VoltageOverload { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace VoltageOverload namespace CurrentOverload { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace CurrentOverload namespace AcOverloadAlarmsMask { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // bitmap16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AcOverloadAlarmsMask namespace AcVoltageOverload { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AcVoltageOverload namespace AcCurrentOverload { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AcCurrentOverload namespace AcActivePowerOverload { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AcActivePowerOverload namespace AcReactivePowerOverload { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AcReactivePowerOverload namespace AverageRmsOverVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AverageRmsOverVoltage namespace AverageRmsUnderVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace AverageRmsUnderVoltage namespace RmsExtremeOverVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace RmsExtremeOverVoltage namespace RmsExtremeUnderVoltage { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace RmsExtremeUnderVoltage namespace RmsVoltageSag { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace RmsVoltageSag namespace RmsVoltageSwell { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace RmsVoltageSwell namespace LineCurrentPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace LineCurrentPhaseB namespace ActiveCurrentPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActiveCurrentPhaseB namespace ReactiveCurrentPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ReactiveCurrentPhaseB namespace RmsVoltagePhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltagePhaseB namespace RmsVoltageMinPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageMinPhaseB namespace RmsVoltageMaxPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageMaxPhaseB namespace RmsCurrentPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentPhaseB namespace RmsCurrentMinPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentMinPhaseB namespace RmsCurrentMaxPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentMaxPhaseB namespace ActivePowerPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerPhaseB namespace ActivePowerMinPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerMinPhaseB namespace ActivePowerMaxPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerMaxPhaseB namespace ReactivePowerPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ReactivePowerPhaseB namespace ApparentPowerPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ApparentPowerPhaseB namespace PowerFactorPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace PowerFactorPhaseB namespace AverageRmsVoltageMeasurementPeriodPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsVoltageMeasurementPeriodPhaseB namespace AverageRmsOverVoltageCounterPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsOverVoltageCounterPhaseB namespace AverageRmsUnderVoltageCounterPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsUnderVoltageCounterPhaseB namespace RmsExtremeOverVoltagePeriodPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsExtremeOverVoltagePeriodPhaseB namespace RmsExtremeUnderVoltagePeriodPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsExtremeUnderVoltagePeriodPhaseB namespace RmsVoltageSagPeriodPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageSagPeriodPhaseB namespace RmsVoltageSwellPeriodPhaseB { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageSwellPeriodPhaseB namespace LineCurrentPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace LineCurrentPhaseC namespace ActiveCurrentPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActiveCurrentPhaseC namespace ReactiveCurrentPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ReactiveCurrentPhaseC namespace RmsVoltagePhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltagePhaseC namespace RmsVoltageMinPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageMinPhaseC namespace RmsVoltageMaxPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageMaxPhaseC namespace RmsCurrentPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentPhaseC namespace RmsCurrentMinPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentMinPhaseC namespace RmsCurrentMaxPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsCurrentMaxPhaseC namespace ActivePowerPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerPhaseC namespace ActivePowerMinPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerMinPhaseC namespace ActivePowerMaxPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ActivePowerMaxPhaseC namespace ReactivePowerPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace ReactivePowerPhaseC namespace ApparentPowerPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ApparentPowerPhaseC namespace PowerFactorPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace PowerFactorPhaseC namespace AverageRmsVoltageMeasurementPeriodPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsVoltageMeasurementPeriodPhaseC namespace AverageRmsOverVoltageCounterPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsOverVoltageCounterPhaseC namespace AverageRmsUnderVoltageCounterPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace AverageRmsUnderVoltageCounterPhaseC namespace RmsExtremeOverVoltagePeriodPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsExtremeOverVoltagePeriodPhaseC namespace RmsExtremeUnderVoltagePeriodPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsExtremeUnderVoltagePeriodPhaseC namespace RmsVoltageSagPeriodPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageSagPeriodPhaseC namespace RmsVoltageSwellPeriodPhaseC { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RmsVoltageSwellPeriodPhaseC namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -4668,27 +4670,27 @@ namespace ClientMonitoring { namespace Attributes { namespace IdleModeInterval { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace IdleModeInterval namespace ActiveModeInterval { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace ActiveModeInterval namespace ActiveModeThreshold { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ActiveModeThreshold namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -4699,216 +4701,216 @@ namespace UnitTesting { namespace Attributes { namespace Boolean { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace Boolean namespace Bitmap8 { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // Bitmap8MaskMap + chip::BitMask * value); // Bitmap8MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Bitmap8 namespace Bitmap16 { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // Bitmap16MaskMap + chip::BitMask * value); // Bitmap16MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Bitmap16 namespace Bitmap32 { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // Bitmap32MaskMap + chip::BitMask * value); // Bitmap32MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Bitmap32 namespace Bitmap64 { EmberAfStatus Get(chip::EndpointId endpoint, - chip::BitMask * value); // Bitmap64MaskMap + chip::BitMask * value); // Bitmap64MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); } // namespace Bitmap64 namespace Int8u { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Int8u namespace Int16u { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Int16u namespace Int24u { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace Int24u namespace Int32u { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace Int32u namespace Int40u { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int40u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int40u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace Int40u namespace Int48u { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int48u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int48u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace Int48u namespace Int56u { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int56u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int56u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace Int56u namespace Int64u { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace Int64u namespace Int8s { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace Int8s namespace Int16s { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace Int16s namespace Int24s { -EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int24s +EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int24s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); } // namespace Int24s namespace Int32s { -EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int32s +EmberAfStatus Get(chip::EndpointId endpoint, int32_t * value); // int32s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); } // namespace Int32s namespace Int40s { -EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int40s +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int40s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); } // namespace Int40s namespace Int48s { -EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int48s +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int48s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); } // namespace Int48s namespace Int56s { -EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int56s +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int56s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); } // namespace Int56s namespace Int64s { -EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int64s +EmberAfStatus Get(chip::EndpointId endpoint, int64_t * value); // int64s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); } // namespace Int64s namespace Enum8 { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace Enum8 namespace Enum16 { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // enum16 +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // enum16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace Enum16 namespace FloatSingle { -EmberAfStatus Get(chip::EndpointId endpoint, float * value); // single +EmberAfStatus Get(chip::EndpointId endpoint, float * value); // single 0 EmberAfStatus Set(chip::EndpointId endpoint, float value); } // namespace FloatSingle namespace FloatDouble { -EmberAfStatus Get(chip::EndpointId endpoint, double * value); // double +EmberAfStatus Get(chip::EndpointId endpoint, double * value); // double 0 EmberAfStatus Set(chip::EndpointId endpoint, double value); } // namespace FloatDouble namespace OctetString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableByteSpan value); // octet_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableByteSpan value); // octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); } // namespace OctetString namespace LongOctetString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableByteSpan value); // long_octet_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableByteSpan value); // long_octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); } // namespace LongOctetString namespace CharString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace CharString namespace LongCharString { -EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string +EmberAfStatus Get(chip::EndpointId endpoint, chip::MutableCharSpan value); // long_char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); } // namespace LongCharString namespace EpochUs { -EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // epoch_us +EmberAfStatus Get(chip::EndpointId endpoint, uint64_t * value); // epoch_us 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); } // namespace EpochUs namespace EpochS { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // epoch_s +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // epoch_s 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace EpochS namespace VendorId { -EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id +EmberAfStatus Get(chip::EndpointId endpoint, chip::VendorId * value); // vendor_id 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::VendorId value); } // namespace VendorId namespace EnumAttr { -EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum * value); // SimpleEnum +EmberAfStatus Get(chip::EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum * value); // SimpleEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value); } // namespace EnumAttr namespace RangeRestrictedInt8u { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace RangeRestrictedInt8u namespace RangeRestrictedInt8s { -EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, int8_t * value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); } // namespace RangeRestrictedInt8s namespace RangeRestrictedInt16u { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace RangeRestrictedInt16u namespace RangeRestrictedInt16s { -EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, int16_t * value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); } // namespace RangeRestrictedInt16s namespace TimedWriteBoolean { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace TimedWriteBoolean namespace GeneralErrorBoolean { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace GeneralErrorBoolean namespace ClusterErrorBoolean { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace ClusterErrorBoolean namespace Unsupported { -EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, bool * value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); } // namespace Unsupported namespace NullableBoolean { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // boolean +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // boolean 0 EmberAfStatus Set(chip::EndpointId endpoint, bool value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -4916,7 +4918,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace NullableBitmap8 { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable> & value); // Bitmap8MaskMap + DataModel::Nullable> & value); // Bitmap8MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -4924,8 +4926,9 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace NullableBitmap8 namespace NullableBitmap16 { -EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable> & value); // Bitmap16MaskMap +EmberAfStatus +Get(chip::EndpointId endpoint, + DataModel::Nullable> & value); // Bitmap16MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -4933,8 +4936,9 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace NullableBitmap16 namespace NullableBitmap32 { -EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable> & value); // Bitmap32MaskMap +EmberAfStatus +Get(chip::EndpointId endpoint, + DataModel::Nullable> & value); // Bitmap32MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -4942,8 +4946,9 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace NullableBitmap32 namespace NullableBitmap64 { -EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable> & value); // Bitmap64MaskMap +EmberAfStatus +Get(chip::EndpointId endpoint, + DataModel::Nullable> & value); // Bitmap64MaskMap 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::BitMask value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -4951,154 +4956,154 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace NullableBitmap64 namespace NullableInt8u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt8u namespace NullableInt16u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt16u namespace NullableInt24u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt24u namespace NullableInt32u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt32u namespace NullableInt40u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int40u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int40u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt40u namespace NullableInt48u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int48u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int48u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt48u namespace NullableInt56u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int56u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int56u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt56u namespace NullableInt64u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt64u namespace NullableInt8s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt8s namespace NullableInt16s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt16s namespace NullableInt24s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int24s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt24s namespace NullableInt32s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int32s 0 EmberAfStatus Set(chip::EndpointId endpoint, int32_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt32s namespace NullableInt40s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int40s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int40s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt40s namespace NullableInt48s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int48s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int48s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt48s namespace NullableInt56s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int56s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int56s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt56s namespace NullableInt64s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int64s 0 EmberAfStatus Set(chip::EndpointId endpoint, int64_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableInt64s namespace NullableEnum8 { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum8 +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum8 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableEnum8 namespace NullableEnum16 { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum16 +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // enum16 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableEnum16 namespace NullableFloatSingle { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // single +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // single 0 EmberAfStatus Set(chip::EndpointId endpoint, float value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableFloatSingle namespace NullableFloatDouble { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // double +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // double 0 EmberAfStatus Set(chip::EndpointId endpoint, double value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableFloatDouble namespace NullableOctetString { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // octet_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::ByteSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableOctetString namespace NullableCharString { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // char_string 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::CharSpan value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); @@ -5106,7 +5111,7 @@ EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullabl namespace NullableEnumAttr { EmberAfStatus Get(chip::EndpointId endpoint, - DataModel::Nullable & value); // SimpleEnum + DataModel::Nullable & value); // SimpleEnum 0 EmberAfStatus Set(chip::EndpointId endpoint, chip::app::Clusters::UnitTesting::SimpleEnum value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, @@ -5114,45 +5119,45 @@ EmberAfStatus Set(chip::EndpointId endpoint, } // namespace NullableEnumAttr namespace NullableRangeRestrictedInt8u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableRangeRestrictedInt8u namespace NullableRangeRestrictedInt8s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int8s 0 EmberAfStatus Set(chip::EndpointId endpoint, int8_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableRangeRestrictedInt8s namespace NullableRangeRestrictedInt16u { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableRangeRestrictedInt16u namespace NullableRangeRestrictedInt16s { -EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s +EmberAfStatus Get(chip::EndpointId endpoint, DataModel::Nullable & value); // int16s 0 EmberAfStatus Set(chip::EndpointId endpoint, int16_t value); EmberAfStatus SetNull(chip::EndpointId endpoint); EmberAfStatus Set(chip::EndpointId endpoint, const chip::app::DataModel::Nullable & value); } // namespace NullableRangeRestrictedInt16s namespace WriteOnlyInt8u { -EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u +EmberAfStatus Get(chip::EndpointId endpoint, uint8_t * value); // int8u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint8_t value); } // namespace WriteOnlyInt8u namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision @@ -5163,12 +5168,12 @@ namespace FaultInjection { namespace Attributes { namespace FeatureMap { -EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 +EmberAfStatus Get(chip::EndpointId endpoint, uint32_t * value); // bitmap32 0 EmberAfStatus Set(chip::EndpointId endpoint, uint32_t value); } // namespace FeatureMap namespace ClusterRevision { -EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u +EmberAfStatus Get(chip::EndpointId endpoint, uint16_t * value); // int16u 0 EmberAfStatus Set(chip::EndpointId endpoint, uint16_t value); } // namespace ClusterRevision