Support mau.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-02-12 Version 1.36.255
+- Support mau.
+
 2020-02-11 Version 1.36.254
 - Return `VpcInstanceId ` for DescribeDBClusterEndpoints.
 - Add DescribeBackupLogs.

VERSION

@@ -1 +1 @@
-1.36.254
+1.36.255

rtc/CMakeLists.txt

@@ -25,12 +25,16 @@ set(rtc_public_header_model
 	include/alibabacloud/rtc/model/CreateChannelResult.h
 	include/alibabacloud/rtc/model/CreateConferenceRequest.h
 	include/alibabacloud/rtc/model/CreateConferenceResult.h
+	include/alibabacloud/rtc/model/CreateMAURuleRequest.h
+	include/alibabacloud/rtc/model/CreateMAURuleResult.h
 	include/alibabacloud/rtc/model/CreateTemplateRequest.h
 	include/alibabacloud/rtc/model/CreateTemplateResult.h
 	include/alibabacloud/rtc/model/DeleteChannelRequest.h
 	include/alibabacloud/rtc/model/DeleteChannelResult.h
 	include/alibabacloud/rtc/model/DeleteConferenceRequest.h
 	include/alibabacloud/rtc/model/DeleteConferenceResult.h
+	include/alibabacloud/rtc/model/DeleteMAURuleRequest.h
+	include/alibabacloud/rtc/model/DeleteMAURuleResult.h
 	include/alibabacloud/rtc/model/DeleteTemplateRequest.h
 	include/alibabacloud/rtc/model/DeleteTemplateResult.h
 	include/alibabacloud/rtc/model/DescribeAppsRequest.h
@@ -39,6 +43,8 @@ set(rtc_public_header_model
 	include/alibabacloud/rtc/model/DescribeChannelParticipantsResult.h
 	include/alibabacloud/rtc/model/DescribeConferenceAuthInfoRequest.h
 	include/alibabacloud/rtc/model/DescribeConferenceAuthInfoResult.h
+	include/alibabacloud/rtc/model/DescribeMAURuleRequest.h
+	include/alibabacloud/rtc/model/DescribeMAURuleResult.h
 	include/alibabacloud/rtc/model/DescribeRtcChannelCntDataRequest.h
 	include/alibabacloud/rtc/model/DescribeRtcChannelCntDataResult.h
 	include/alibabacloud/rtc/model/DescribeRtcChannelListRequest.h
@@ -53,8 +59,16 @@ set(rtc_public_header_model
 	include/alibabacloud/rtc/model/DescribeRtcPeakChannelCntDataResult.h
 	include/alibabacloud/rtc/model/DescribeRtcPeakUserCntDataRequest.h
 	include/alibabacloud/rtc/model/DescribeRtcPeakUserCntDataResult.h
+	include/alibabacloud/rtc/model/DescribeRtcQualityMetricRequest.h
+	include/alibabacloud/rtc/model/DescribeRtcQualityMetricResult.h
 	include/alibabacloud/rtc/model/DescribeRtcUserCntDataRequest.h
 	include/alibabacloud/rtc/model/DescribeRtcUserCntDataResult.h
+	include/alibabacloud/rtc/model/DescribeRtcUserListRequest.h
+	include/alibabacloud/rtc/model/DescribeRtcUserListResult.h
+	include/alibabacloud/rtc/model/DisableMAURuleRequest.h
+	include/alibabacloud/rtc/model/DisableMAURuleResult.h
+	include/alibabacloud/rtc/model/EnableMAURuleRequest.h
+	include/alibabacloud/rtc/model/EnableMAURuleResult.h
 	include/alibabacloud/rtc/model/GetMPUTaskStatusRequest.h
 	include/alibabacloud/rtc/model/GetMPUTaskStatusResult.h
 	include/alibabacloud/rtc/model/GetTaskStatusRequest.h
@@ -96,12 +110,16 @@ set(rtc_src
 	src/model/CreateChannelResult.cc
 	src/model/CreateConferenceRequest.cc
 	src/model/CreateConferenceResult.cc
+	src/model/CreateMAURuleRequest.cc
+	src/model/CreateMAURuleResult.cc
 	src/model/CreateTemplateRequest.cc
 	src/model/CreateTemplateResult.cc
 	src/model/DeleteChannelRequest.cc
 	src/model/DeleteChannelResult.cc
 	src/model/DeleteConferenceRequest.cc
 	src/model/DeleteConferenceResult.cc
+	src/model/DeleteMAURuleRequest.cc
+	src/model/DeleteMAURuleResult.cc
 	src/model/DeleteTemplateRequest.cc
 	src/model/DeleteTemplateResult.cc
 	src/model/DescribeAppsRequest.cc
@@ -110,6 +128,8 @@ set(rtc_src
 	src/model/DescribeChannelParticipantsResult.cc
 	src/model/DescribeConferenceAuthInfoRequest.cc
 	src/model/DescribeConferenceAuthInfoResult.cc
+	src/model/DescribeMAURuleRequest.cc
+	src/model/DescribeMAURuleResult.cc
 	src/model/DescribeRtcChannelCntDataRequest.cc
 	src/model/DescribeRtcChannelCntDataResult.cc
 	src/model/DescribeRtcChannelListRequest.cc
@@ -124,8 +144,16 @@ set(rtc_src
 	src/model/DescribeRtcPeakChannelCntDataResult.cc
 	src/model/DescribeRtcPeakUserCntDataRequest.cc
 	src/model/DescribeRtcPeakUserCntDataResult.cc
+	src/model/DescribeRtcQualityMetricRequest.cc
+	src/model/DescribeRtcQualityMetricResult.cc
 	src/model/DescribeRtcUserCntDataRequest.cc
 	src/model/DescribeRtcUserCntDataResult.cc
+	src/model/DescribeRtcUserListRequest.cc
+	src/model/DescribeRtcUserListResult.cc
+	src/model/DisableMAURuleRequest.cc
+	src/model/DisableMAURuleResult.cc
+	src/model/EnableMAURuleRequest.cc
+	src/model/EnableMAURuleResult.cc
 	src/model/GetMPUTaskStatusRequest.cc
 	src/model/GetMPUTaskStatusResult.cc
 	src/model/GetTaskStatusRequest.cc

rtc/include/alibabacloud/rtc/RtcClient.h

@@ -26,12 +26,16 @@
 #include "model/CreateChannelResult.h"
 #include "model/CreateConferenceRequest.h"
 #include "model/CreateConferenceResult.h"
+#include "model/CreateMAURuleRequest.h"
+#include "model/CreateMAURuleResult.h"
 #include "model/CreateTemplateRequest.h"
 #include "model/CreateTemplateResult.h"
 #include "model/DeleteChannelRequest.h"
 #include "model/DeleteChannelResult.h"
 #include "model/DeleteConferenceRequest.h"
 #include "model/DeleteConferenceResult.h"
+#include "model/DeleteMAURuleRequest.h"
+#include "model/DeleteMAURuleResult.h"
 #include "model/DeleteTemplateRequest.h"
 #include "model/DeleteTemplateResult.h"
 #include "model/DescribeAppsRequest.h"
@@ -40,6 +44,8 @@
 #include "model/DescribeChannelParticipantsResult.h"
 #include "model/DescribeConferenceAuthInfoRequest.h"
 #include "model/DescribeConferenceAuthInfoResult.h"
+#include "model/DescribeMAURuleRequest.h"
+#include "model/DescribeMAURuleResult.h"
 #include "model/DescribeRtcChannelCntDataRequest.h"
 #include "model/DescribeRtcChannelCntDataResult.h"
 #include "model/DescribeRtcChannelListRequest.h"
@@ -54,8 +60,16 @@
 #include "model/DescribeRtcPeakChannelCntDataResult.h"
 #include "model/DescribeRtcPeakUserCntDataRequest.h"
 #include "model/DescribeRtcPeakUserCntDataResult.h"
+#include "model/DescribeRtcQualityMetricRequest.h"
+#include "model/DescribeRtcQualityMetricResult.h"
 #include "model/DescribeRtcUserCntDataRequest.h"
 #include "model/DescribeRtcUserCntDataResult.h"
+#include "model/DescribeRtcUserListRequest.h"
+#include "model/DescribeRtcUserListResult.h"
+#include "model/DisableMAURuleRequest.h"
+#include "model/DisableMAURuleResult.h"
+#include "model/EnableMAURuleRequest.h"
+#include "model/EnableMAURuleResult.h"
 #include "model/GetMPUTaskStatusRequest.h"
 #include "model/GetMPUTaskStatusResult.h"
 #include "model/GetTaskStatusRequest.h"
@@ -105,6 +119,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateConferenceResult> CreateConferenceOutcome;
 			typedef std::future<CreateConferenceOutcome> CreateConferenceOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::CreateConferenceRequest&, const CreateConferenceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConferenceAsyncHandler;
+			typedef Outcome<Error, Model::CreateMAURuleResult> CreateMAURuleOutcome;
+			typedef std::future<CreateMAURuleOutcome> CreateMAURuleOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::CreateMAURuleRequest&, const CreateMAURuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMAURuleAsyncHandler;
 			typedef Outcome<Error, Model::CreateTemplateResult> CreateTemplateOutcome;
 			typedef std::future<CreateTemplateOutcome> CreateTemplateOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::CreateTemplateRequest&, const CreateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTemplateAsyncHandler;
@@ -114,6 +131,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteConferenceResult> DeleteConferenceOutcome;
 			typedef std::future<DeleteConferenceOutcome> DeleteConferenceOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DeleteConferenceRequest&, const DeleteConferenceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteConferenceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteMAURuleResult> DeleteMAURuleOutcome;
+			typedef std::future<DeleteMAURuleOutcome> DeleteMAURuleOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DeleteMAURuleRequest&, const DeleteMAURuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMAURuleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteTemplateResult> DeleteTemplateOutcome;
 			typedef std::future<DeleteTemplateOutcome> DeleteTemplateOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DeleteTemplateRequest&, const DeleteTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTemplateAsyncHandler;
@@ -126,6 +146,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeConferenceAuthInfoResult> DescribeConferenceAuthInfoOutcome;
 			typedef std::future<DescribeConferenceAuthInfoOutcome> DescribeConferenceAuthInfoOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DescribeConferenceAuthInfoRequest&, const DescribeConferenceAuthInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConferenceAuthInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeMAURuleResult> DescribeMAURuleOutcome;
+			typedef std::future<DescribeMAURuleOutcome> DescribeMAURuleOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DescribeMAURuleRequest&, const DescribeMAURuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMAURuleAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRtcChannelCntDataResult> DescribeRtcChannelCntDataOutcome;
 			typedef std::future<DescribeRtcChannelCntDataOutcome> DescribeRtcChannelCntDataOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DescribeRtcChannelCntDataRequest&, const DescribeRtcChannelCntDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcChannelCntDataAsyncHandler;
@@ -147,9 +170,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeRtcPeakUserCntDataResult> DescribeRtcPeakUserCntDataOutcome;
 			typedef std::future<DescribeRtcPeakUserCntDataOutcome> DescribeRtcPeakUserCntDataOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DescribeRtcPeakUserCntDataRequest&, const DescribeRtcPeakUserCntDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcPeakUserCntDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRtcQualityMetricResult> DescribeRtcQualityMetricOutcome;
+			typedef std::future<DescribeRtcQualityMetricOutcome> DescribeRtcQualityMetricOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DescribeRtcQualityMetricRequest&, const DescribeRtcQualityMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcQualityMetricAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRtcUserCntDataResult> DescribeRtcUserCntDataOutcome;
 			typedef std::future<DescribeRtcUserCntDataOutcome> DescribeRtcUserCntDataOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::DescribeRtcUserCntDataRequest&, const DescribeRtcUserCntDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcUserCntDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRtcUserListResult> DescribeRtcUserListOutcome;
+			typedef std::future<DescribeRtcUserListOutcome> DescribeRtcUserListOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DescribeRtcUserListRequest&, const DescribeRtcUserListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRtcUserListAsyncHandler;
+			typedef Outcome<Error, Model::DisableMAURuleResult> DisableMAURuleOutcome;
+			typedef std::future<DisableMAURuleOutcome> DisableMAURuleOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::DisableMAURuleRequest&, const DisableMAURuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableMAURuleAsyncHandler;
+			typedef Outcome<Error, Model::EnableMAURuleResult> EnableMAURuleOutcome;
+			typedef std::future<EnableMAURuleOutcome> EnableMAURuleOutcomeCallable;
+			typedef std::function<void(const RtcClient*, const Model::EnableMAURuleRequest&, const EnableMAURuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableMAURuleAsyncHandler;
 			typedef Outcome<Error, Model::GetMPUTaskStatusResult> GetMPUTaskStatusOutcome;
 			typedef std::future<GetMPUTaskStatusOutcome> GetMPUTaskStatusOutcomeCallable;
 			typedef std::function<void(const RtcClient*, const Model::GetMPUTaskStatusRequest&, const GetMPUTaskStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMPUTaskStatusAsyncHandler;
@@ -212,6 +247,9 @@ namespace AlibabaCloud
 			CreateConferenceOutcome createConference(const Model::CreateConferenceRequest &request)const;
 			void createConferenceAsync(const Model::CreateConferenceRequest& request, const CreateConferenceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateConferenceOutcomeCallable createConferenceCallable(const Model::CreateConferenceRequest& request) const;
+			CreateMAURuleOutcome createMAURule(const Model::CreateMAURuleRequest &request)const;
+			void createMAURuleAsync(const Model::CreateMAURuleRequest& request, const CreateMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateMAURuleOutcomeCallable createMAURuleCallable(const Model::CreateMAURuleRequest& request) const;
 			CreateTemplateOutcome createTemplate(const Model::CreateTemplateRequest &request)const;
 			void createTemplateAsync(const Model::CreateTemplateRequest& request, const CreateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateTemplateOutcomeCallable createTemplateCallable(const Model::CreateTemplateRequest& request) const;
@@ -221,6 +259,9 @@ namespace AlibabaCloud
 			DeleteConferenceOutcome deleteConference(const Model::DeleteConferenceRequest &request)const;
 			void deleteConferenceAsync(const Model::DeleteConferenceRequest& request, const DeleteConferenceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteConferenceOutcomeCallable deleteConferenceCallable(const Model::DeleteConferenceRequest& request) const;
+			DeleteMAURuleOutcome deleteMAURule(const Model::DeleteMAURuleRequest &request)const;
+			void deleteMAURuleAsync(const Model::DeleteMAURuleRequest& request, const DeleteMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteMAURuleOutcomeCallable deleteMAURuleCallable(const Model::DeleteMAURuleRequest& request) const;
 			DeleteTemplateOutcome deleteTemplate(const Model::DeleteTemplateRequest &request)const;
 			void deleteTemplateAsync(const Model::DeleteTemplateRequest& request, const DeleteTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteTemplateOutcomeCallable deleteTemplateCallable(const Model::DeleteTemplateRequest& request) const;
@@ -233,6 +274,9 @@ namespace AlibabaCloud
 			DescribeConferenceAuthInfoOutcome describeConferenceAuthInfo(const Model::DescribeConferenceAuthInfoRequest &request)const;
 			void describeConferenceAuthInfoAsync(const Model::DescribeConferenceAuthInfoRequest& request, const DescribeConferenceAuthInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeConferenceAuthInfoOutcomeCallable describeConferenceAuthInfoCallable(const Model::DescribeConferenceAuthInfoRequest& request) const;
+			DescribeMAURuleOutcome describeMAURule(const Model::DescribeMAURuleRequest &request)const;
+			void describeMAURuleAsync(const Model::DescribeMAURuleRequest& request, const DescribeMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeMAURuleOutcomeCallable describeMAURuleCallable(const Model::DescribeMAURuleRequest& request) const;
 			DescribeRtcChannelCntDataOutcome describeRtcChannelCntData(const Model::DescribeRtcChannelCntDataRequest &request)const;
 			void describeRtcChannelCntDataAsync(const Model::DescribeRtcChannelCntDataRequest& request, const DescribeRtcChannelCntDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRtcChannelCntDataOutcomeCallable describeRtcChannelCntDataCallable(const Model::DescribeRtcChannelCntDataRequest& request) const;
@@ -254,9 +298,21 @@ namespace AlibabaCloud
 			DescribeRtcPeakUserCntDataOutcome describeRtcPeakUserCntData(const Model::DescribeRtcPeakUserCntDataRequest &request)const;
 			void describeRtcPeakUserCntDataAsync(const Model::DescribeRtcPeakUserCntDataRequest& request, const DescribeRtcPeakUserCntDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRtcPeakUserCntDataOutcomeCallable describeRtcPeakUserCntDataCallable(const Model::DescribeRtcPeakUserCntDataRequest& request) const;
+			DescribeRtcQualityMetricOutcome describeRtcQualityMetric(const Model::DescribeRtcQualityMetricRequest &request)const;
+			void describeRtcQualityMetricAsync(const Model::DescribeRtcQualityMetricRequest& request, const DescribeRtcQualityMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRtcQualityMetricOutcomeCallable describeRtcQualityMetricCallable(const Model::DescribeRtcQualityMetricRequest& request) const;
 			DescribeRtcUserCntDataOutcome describeRtcUserCntData(const Model::DescribeRtcUserCntDataRequest &request)const;
 			void describeRtcUserCntDataAsync(const Model::DescribeRtcUserCntDataRequest& request, const DescribeRtcUserCntDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRtcUserCntDataOutcomeCallable describeRtcUserCntDataCallable(const Model::DescribeRtcUserCntDataRequest& request) const;
+			DescribeRtcUserListOutcome describeRtcUserList(const Model::DescribeRtcUserListRequest &request)const;
+			void describeRtcUserListAsync(const Model::DescribeRtcUserListRequest& request, const DescribeRtcUserListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRtcUserListOutcomeCallable describeRtcUserListCallable(const Model::DescribeRtcUserListRequest& request) const;
+			DisableMAURuleOutcome disableMAURule(const Model::DisableMAURuleRequest &request)const;
+			void disableMAURuleAsync(const Model::DisableMAURuleRequest& request, const DisableMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableMAURuleOutcomeCallable disableMAURuleCallable(const Model::DisableMAURuleRequest& request) const;
+			EnableMAURuleOutcome enableMAURule(const Model::EnableMAURuleRequest &request)const;
+			void enableMAURuleAsync(const Model::EnableMAURuleRequest& request, const EnableMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableMAURuleOutcomeCallable enableMAURuleCallable(const Model::EnableMAURuleRequest& request) const;
 			GetMPUTaskStatusOutcome getMPUTaskStatus(const Model::GetMPUTaskStatusRequest &request)const;
 			void getMPUTaskStatusAsync(const Model::GetMPUTaskStatusRequest& request, const GetMPUTaskStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMPUTaskStatusOutcomeCallable getMPUTaskStatusCallable(const Model::GetMPUTaskStatusRequest& request) const;

rtc/include/alibabacloud/rtc/model/CreateMAURuleRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_CREATEMAURULEREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_CREATEMAURULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT CreateMAURuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateMAURuleRequest();
+				~CreateMAURuleRequest();
+
+				std::string getUseridPrefix()const;
+				void setUseridPrefix(const std::string& useridPrefix);
+				std::string getChannelPrefix()const;
+				void setChannelPrefix(const std::string& channelPrefix);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				long getMauTemplateId()const;
+				void setMauTemplateId(long mauTemplateId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+				std::string getCallBack()const;
+				void setCallBack(const std::string& callBack);
+
+            private:
+				std::string useridPrefix_;
+				std::string channelPrefix_;
+				long ownerId_;
+				long mauTemplateId_;
+				std::string appId_;
+				std::string callBack_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_CREATEMAURULEREQUEST_H_

rtc/include/alibabacloud/rtc/model/CreateMAURuleResult.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_CREATEMAURULERESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_CREATEMAURULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT CreateMAURuleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateMAURuleResult();
+				explicit CreateMAURuleResult(const std::string &payload);
+				~CreateMAURuleResult();
+				long getRuleId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long ruleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_CREATEMAURULERESULT_H_

rtc/include/alibabacloud/rtc/model/CreateTemplateRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_RTC_EXPORT CreateTemplateRequest : public RpcServiceRequest
 			{
+			public:
 				struct LiveConfig
 				{
 					std::string domainName;

rtc/include/alibabacloud/rtc/model/DeleteMAURuleRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DELETEMAURULEREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DELETEMAURULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DeleteMAURuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteMAURuleRequest();
+				~DeleteMAURuleRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+				long getRuleId()const;
+				void setRuleId(long ruleId);
+
+            private:
+				long ownerId_;
+				std::string appId_;
+				long ruleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DELETEMAURULEREQUEST_H_

rtc/include/alibabacloud/rtc/model/DeleteMAURuleResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DELETEMAURULERESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DELETEMAURULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DeleteMAURuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteMAURuleResult();
+				explicit DeleteMAURuleResult(const std::string &payload);
+				~DeleteMAURuleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DELETEMAURULERESULT_H_

rtc/include/alibabacloud/rtc/model/DescribeMAURuleRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DESCRIBEMAURULEREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBEMAURULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeMAURuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeMAURuleRequest();
+				~DescribeMAURuleRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+
+            private:
+				long ownerId_;
+				std::string appId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBEMAURULEREQUEST_H_

rtc/include/alibabacloud/rtc/model/DescribeMAURuleResult.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DESCRIBEMAURULERESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBEMAURULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeMAURuleResult : public ServiceResult
+			{
+			public:
+				struct Rule
+				{
+					std::string channelPrefix;
+					int isEnable;
+					std::string callBack;
+					long ruleId;
+					std::string useridPrefix;
+					long templateId;
+				};
+
+
+				DescribeMAURuleResult();
+				explicit DescribeMAURuleResult(const std::string &payload);
+				~DescribeMAURuleResult();
+				std::vector<Rule> getRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Rule> rules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBEMAURULERESULT_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcQualityMetricRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DESCRIBERTCQUALITYMETRICREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCQUALITYMETRICREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcQualityMetricRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRtcQualityMetricRequest();
+				~DescribeRtcQualityMetricRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getSubUser()const;
+				void setSubUser(const std::string& subUser);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getPubUser()const;
+				void setPubUser(const std::string& pubUser);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+				std::string getChannelId()const;
+				void setChannelId(const std::string& channelId);
+
+            private:
+				std::string startTime_;
+				std::string subUser_;
+				std::string endTime_;
+				long ownerId_;
+				std::string pubUser_;
+				std::string appId_;
+				std::string channelId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCQUALITYMETRICREQUEST_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcQualityMetricResult.h

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DESCRIBERTCQUALITYMETRICRESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCQUALITYMETRICRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcQualityMetricResult : public ServiceResult
+			{
+			public:
+				struct QualityMetric
+				{
+					struct SubInfo
+					{
+						struct User
+						{
+							std::string oS;
+							std::string userId;
+							std::string sDKVersion;
+							std::string province;
+						};
+						struct DataItem
+						{
+							struct Fps
+							{
+								long small;
+								long super;
+								long large;
+								long share;
+							};
+							struct Resolution
+							{
+								long small;
+								long super;
+								long large;
+								long share;
+							};
+							struct BitRate
+							{
+								long small;
+								long super;
+								long large;
+								long audio;
+								long share;
+							};
+							struct Network
+							{
+								long rtt;
+								float loss;
+							};
+							Network network;
+							Fps fps;
+							std::string time;
+							BitRate bitRate;
+							Resolution resolution;
+						};
+						struct EventsItem
+						{
+							std::string category;
+							std::string description;
+							long eventId;
+							std::string time;
+							std::string name;
+							std::string result;
+						};
+						User user;
+						std::vector<EventsItem> events;
+						std::vector<DataItem> data;
+					};
+					struct PubInfo
+					{
+						struct User1
+						{
+							std::string oS;
+							std::string userId;
+							std::string sDKVersion;
+							std::string province;
+						};
+						struct DataItem4
+						{
+							struct Fps5
+							{
+								long small;
+								long super;
+								long large;
+								long share;
+							};
+							struct Resolution6
+							{
+								long small;
+								long super;
+								long large;
+								long share;
+							};
+							struct BitRate7
+							{
+								long small;
+								long super;
+								long large;
+								long audio;
+								long share;
+							};
+							struct Network8
+							{
+								long rtt;
+								float loss;
+							};
+							BitRate7 bitRate7;
+							std::string time;
+							Fps5 fps5;
+							Resolution6 resolution6;
+							Network8 network8;
+						};
+						struct EventsItem9
+						{
+							std::string category;
+							std::string description;
+							long eventId;
+							std::string time;
+							std::string name;
+							std::string result;
+						};
+						std::vector<DataItem4> data2;
+						User1 user1;
+						std::vector<EventsItem9> events3;
+					};
+					SubInfo subInfo;
+					PubInfo pubInfo;
+				};
+
+
+				DescribeRtcQualityMetricResult();
+				explicit DescribeRtcQualityMetricResult(const std::string &payload);
+				~DescribeRtcQualityMetricResult();
+				QualityMetric getQualityMetric()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				QualityMetric qualityMetric_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCQUALITYMETRICRESULT_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcUserListRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DESCRIBERTCUSERLISTREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCUSERLISTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcUserListRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRtcUserListRequest();
+				~DescribeRtcUserListRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+				std::string getChannelId()const;
+				void setChannelId(const std::string& channelId);
+
+            private:
+				std::string startTime_;
+				std::string endTime_;
+				long ownerId_;
+				std::string appId_;
+				std::string channelId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCUSERLISTREQUEST_H_

rtc/include/alibabacloud/rtc/model/DescribeRtcUserListResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DESCRIBERTCUSERLISTRESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DESCRIBERTCUSERLISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DescribeRtcUserListResult : public ServiceResult
+			{
+			public:
+				struct UserListItem
+				{
+					std::string user;
+				};
+
+
+				DescribeRtcUserListResult();
+				explicit DescribeRtcUserListResult(const std::string &payload);
+				~DescribeRtcUserListResult();
+				std::vector<UserListItem> getUserList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<UserListItem> userList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DESCRIBERTCUSERLISTRESULT_H_

rtc/include/alibabacloud/rtc/model/DisableMAURuleRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DISABLEMAURULEREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_DISABLEMAURULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DisableMAURuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				DisableMAURuleRequest();
+				~DisableMAURuleRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+				long getRuleId()const;
+				void setRuleId(long ruleId);
+
+            private:
+				long ownerId_;
+				std::string appId_;
+				long ruleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DISABLEMAURULEREQUEST_H_

rtc/include/alibabacloud/rtc/model/DisableMAURuleResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_DISABLEMAURULERESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_DISABLEMAURULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT DisableMAURuleResult : public ServiceResult
+			{
+			public:
+
+
+				DisableMAURuleResult();
+				explicit DisableMAURuleResult(const std::string &payload);
+				~DisableMAURuleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_DISABLEMAURULERESULT_H_

rtc/include/alibabacloud/rtc/model/EnableMAURuleRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_ENABLEMAURULEREQUEST_H_
+#define ALIBABACLOUD_RTC_MODEL_ENABLEMAURULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT EnableMAURuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnableMAURuleRequest();
+				~EnableMAURuleRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAppId()const;
+				void setAppId(const std::string& appId);
+				long getRuleId()const;
+				void setRuleId(long ruleId);
+
+            private:
+				long ownerId_;
+				std::string appId_;
+				long ruleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_ENABLEMAURULEREQUEST_H_

rtc/include/alibabacloud/rtc/model/EnableMAURuleResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RTC_MODEL_ENABLEMAURULERESULT_H_
+#define ALIBABACLOUD_RTC_MODEL_ENABLEMAURULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rtc/RtcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rtc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RTC_EXPORT EnableMAURuleResult : public ServiceResult
+			{
+			public:
+
+
+				EnableMAURuleResult();
+				explicit EnableMAURuleResult(const std::string &payload);
+				~EnableMAURuleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RTC_MODEL_ENABLEMAURULERESULT_H_

rtc/include/alibabacloud/rtc/model/StartMPUTaskRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_RTC_EXPORT StartMPUTaskRequest : public RpcServiceRequest
 			{
+			public:
 				struct UserPanes
 				{
 					int paneId;

rtc/include/alibabacloud/rtc/model/StartTaskRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_RTC_EXPORT StartTaskRequest : public RpcServiceRequest
 			{
+			public:
 				struct MixPanes
 				{
 					int paneId;

rtc/include/alibabacloud/rtc/model/UpdateMPULayoutRequest.h

@@ -30,6 +30,7 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_RTC_EXPORT UpdateMPULayoutRequest : public RpcServiceRequest
 			{
+			public:
 				struct UserPanes
 				{
 					int paneId;

rtc/src/RtcClient.cc

@@ -123,6 +123,42 @@ RtcClient::CreateConferenceOutcomeCallable RtcClient::createConferenceCallable(c
 	return task->get_future();
 }
 
+RtcClient::CreateMAURuleOutcome RtcClient::createMAURule(const CreateMAURuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateMAURuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateMAURuleOutcome(CreateMAURuleResult(outcome.result()));
+	else
+		return CreateMAURuleOutcome(outcome.error());
+}
+
+void RtcClient::createMAURuleAsync(const CreateMAURuleRequest& request, const CreateMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createMAURule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::CreateMAURuleOutcomeCallable RtcClient::createMAURuleCallable(const CreateMAURuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateMAURuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createMAURule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RtcClient::CreateTemplateOutcome RtcClient::createTemplate(const CreateTemplateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +267,42 @@ RtcClient::DeleteConferenceOutcomeCallable RtcClient::deleteConferenceCallable(c
 	return task->get_future();
 }
 
+RtcClient::DeleteMAURuleOutcome RtcClient::deleteMAURule(const DeleteMAURuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteMAURuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteMAURuleOutcome(DeleteMAURuleResult(outcome.result()));
+	else
+		return DeleteMAURuleOutcome(outcome.error());
+}
+
+void RtcClient::deleteMAURuleAsync(const DeleteMAURuleRequest& request, const DeleteMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteMAURule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DeleteMAURuleOutcomeCallable RtcClient::deleteMAURuleCallable(const DeleteMAURuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteMAURuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteMAURule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RtcClient::DeleteTemplateOutcome RtcClient::deleteTemplate(const DeleteTemplateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +447,42 @@ RtcClient::DescribeConferenceAuthInfoOutcomeCallable RtcClient::describeConferen
 	return task->get_future();
 }
 
+RtcClient::DescribeMAURuleOutcome RtcClient::describeMAURule(const DescribeMAURuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeMAURuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeMAURuleOutcome(DescribeMAURuleResult(outcome.result()));
+	else
+		return DescribeMAURuleOutcome(outcome.error());
+}
+
+void RtcClient::describeMAURuleAsync(const DescribeMAURuleRequest& request, const DescribeMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeMAURule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DescribeMAURuleOutcomeCallable RtcClient::describeMAURuleCallable(const DescribeMAURuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeMAURuleOutcome()>>(
+			[this, request]()
+			{
+			return this->describeMAURule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RtcClient::DescribeRtcChannelCntDataOutcome RtcClient::describeRtcChannelCntData(const DescribeRtcChannelCntDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -627,6 +735,42 @@ RtcClient::DescribeRtcPeakUserCntDataOutcomeCallable RtcClient::describeRtcPeakU
 	return task->get_future();
 }
 
+RtcClient::DescribeRtcQualityMetricOutcome RtcClient::describeRtcQualityMetric(const DescribeRtcQualityMetricRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRtcQualityMetricOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRtcQualityMetricOutcome(DescribeRtcQualityMetricResult(outcome.result()));
+	else
+		return DescribeRtcQualityMetricOutcome(outcome.error());
+}
+
+void RtcClient::describeRtcQualityMetricAsync(const DescribeRtcQualityMetricRequest& request, const DescribeRtcQualityMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRtcQualityMetric(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DescribeRtcQualityMetricOutcomeCallable RtcClient::describeRtcQualityMetricCallable(const DescribeRtcQualityMetricRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRtcQualityMetricOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRtcQualityMetric(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RtcClient::DescribeRtcUserCntDataOutcome RtcClient::describeRtcUserCntData(const DescribeRtcUserCntDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -663,6 +807,114 @@ RtcClient::DescribeRtcUserCntDataOutcomeCallable RtcClient::describeRtcUserCntDa
 	return task->get_future();
 }
 
+RtcClient::DescribeRtcUserListOutcome RtcClient::describeRtcUserList(const DescribeRtcUserListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRtcUserListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRtcUserListOutcome(DescribeRtcUserListResult(outcome.result()));
+	else
+		return DescribeRtcUserListOutcome(outcome.error());
+}
+
+void RtcClient::describeRtcUserListAsync(const DescribeRtcUserListRequest& request, const DescribeRtcUserListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRtcUserList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DescribeRtcUserListOutcomeCallable RtcClient::describeRtcUserListCallable(const DescribeRtcUserListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRtcUserListOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRtcUserList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RtcClient::DisableMAURuleOutcome RtcClient::disableMAURule(const DisableMAURuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableMAURuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableMAURuleOutcome(DisableMAURuleResult(outcome.result()));
+	else
+		return DisableMAURuleOutcome(outcome.error());
+}
+
+void RtcClient::disableMAURuleAsync(const DisableMAURuleRequest& request, const DisableMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableMAURule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::DisableMAURuleOutcomeCallable RtcClient::disableMAURuleCallable(const DisableMAURuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableMAURuleOutcome()>>(
+			[this, request]()
+			{
+			return this->disableMAURule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RtcClient::EnableMAURuleOutcome RtcClient::enableMAURule(const EnableMAURuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableMAURuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableMAURuleOutcome(EnableMAURuleResult(outcome.result()));
+	else
+		return EnableMAURuleOutcome(outcome.error());
+}
+
+void RtcClient::enableMAURuleAsync(const EnableMAURuleRequest& request, const EnableMAURuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableMAURule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RtcClient::EnableMAURuleOutcomeCallable RtcClient::enableMAURuleCallable(const EnableMAURuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableMAURuleOutcome()>>(
+			[this, request]()
+			{
+			return this->enableMAURule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RtcClient::GetMPUTaskStatusOutcome RtcClient::getMPUTaskStatus(const GetMPUTaskStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

rtc/src/model/CreateChannelRequest.cc

@@ -35,7 +35,7 @@ long CreateChannelRequest::getOwnerId()const
 void CreateChannelRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateChannelRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string CreateChannelRequest::getAppId()const
 void CreateChannelRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string CreateChannelRequest::getChannelId()const
@@ -57,6 +57,6 @@ std::string CreateChannelRequest::getChannelId()const
 void CreateChannelRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/CreateConferenceRequest.cc

@@ -35,7 +35,7 @@ std::string CreateConferenceRequest::getClientToken()const
 void CreateConferenceRequest::setClientToken(const std::string& clientToken)
 {
 	clientToken_ = clientToken;
-	setCoreParameter("ClientToken", clientToken);
+	setParameter("ClientToken", clientToken);
 }
 
 std::string CreateConferenceRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string CreateConferenceRequest::getStartTime()const
 void CreateConferenceRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string CreateConferenceRequest::getType()const
@@ -57,7 +57,7 @@ std::string CreateConferenceRequest::getType()const
 void CreateConferenceRequest::setType(const std::string& type)
 {
 	type_ = type;
-	setCoreParameter("Type", type);
+	setParameter("Type", type);
 }
 
 std::string CreateConferenceRequest::getConferenceName()const
@@ -68,7 +68,7 @@ std::string CreateConferenceRequest::getConferenceName()const
 void CreateConferenceRequest::setConferenceName(const std::string& conferenceName)
 {
 	conferenceName_ = conferenceName;
-	setCoreParameter("ConferenceName", conferenceName);
+	setParameter("ConferenceName", conferenceName);
 }
 
 long CreateConferenceRequest::getOwnerId()const
@@ -79,7 +79,7 @@ long CreateConferenceRequest::getOwnerId()const
 void CreateConferenceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CreateConferenceRequest::getAppId()const
@@ -90,7 +90,7 @@ std::string CreateConferenceRequest::getAppId()const
 void CreateConferenceRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 int CreateConferenceRequest::getRemindNotice()const
@@ -101,6 +101,6 @@ int CreateConferenceRequest::getRemindNotice()const
 void CreateConferenceRequest::setRemindNotice(int remindNotice)
 {
 	remindNotice_ = remindNotice;
-	setCoreParameter("RemindNotice", std::to_string(remindNotice));
+	setParameter("RemindNotice", std::to_string(remindNotice));
 }
 

rtc/src/model/CreateMAURuleRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/CreateMAURuleRequest.h>
+
+using AlibabaCloud::Rtc::Model::CreateMAURuleRequest;
+
+CreateMAURuleRequest::CreateMAURuleRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "CreateMAURule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateMAURuleRequest::~CreateMAURuleRequest()
+{}
+
+std::string CreateMAURuleRequest::getUseridPrefix()const
+{
+	return useridPrefix_;
+}
+
+void CreateMAURuleRequest::setUseridPrefix(const std::string& useridPrefix)
+{
+	useridPrefix_ = useridPrefix;
+	setParameter("UseridPrefix", useridPrefix);
+}
+
+std::string CreateMAURuleRequest::getChannelPrefix()const
+{
+	return channelPrefix_;
+}
+
+void CreateMAURuleRequest::setChannelPrefix(const std::string& channelPrefix)
+{
+	channelPrefix_ = channelPrefix;
+	setParameter("ChannelPrefix", channelPrefix);
+}
+
+long CreateMAURuleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateMAURuleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+long CreateMAURuleRequest::getMauTemplateId()const
+{
+	return mauTemplateId_;
+}
+
+void CreateMAURuleRequest::setMauTemplateId(long mauTemplateId)
+{
+	mauTemplateId_ = mauTemplateId;
+	setParameter("MauTemplateId", std::to_string(mauTemplateId));
+}
+
+std::string CreateMAURuleRequest::getAppId()const
+{
+	return appId_;
+}
+
+void CreateMAURuleRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+
+std::string CreateMAURuleRequest::getCallBack()const
+{
+	return callBack_;
+}
+
+void CreateMAURuleRequest::setCallBack(const std::string& callBack)
+{
+	callBack_ = callBack;
+	setParameter("CallBack", callBack);
+}
+

rtc/src/model/CreateMAURuleResult.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/CreateMAURuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+CreateMAURuleResult::CreateMAURuleResult() :
+	ServiceResult()
+{}
+
+CreateMAURuleResult::CreateMAURuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateMAURuleResult::~CreateMAURuleResult()
+{}
+
+void CreateMAURuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["RuleId"].isNull())
+		ruleId_ = std::stol(value["RuleId"].asString());
+
+}
+
+long CreateMAURuleResult::getRuleId()const
+{
+	return ruleId_;
+}
+

rtc/src/model/CreateTemplateRequest.cc

@@ -35,7 +35,7 @@ int CreateTemplateRequest::getServiceMode()const
 void CreateTemplateRequest::setServiceMode(int serviceMode)
 {
 	serviceMode_ = serviceMode;
-	setCoreParameter("ServiceMode", std::to_string(serviceMode));
+	setParameter("ServiceMode", std::to_string(serviceMode));
 }
 
 std::vector<CreateTemplateRequest::LiveConfig> CreateTemplateRequest::getLiveConfig()const
@@ -48,9 +48,9 @@ void CreateTemplateRequest::setLiveConfig(const std::vector<LiveConfig>& liveCon
 	liveConfig_ = liveConfig;
 	for(int dep1 = 0; dep1!= liveConfig.size(); dep1++) {
 		auto liveConfigObj = liveConfig.at(dep1);
-		std::string liveConfigObjStr = "LiveConfig." + std::to_string(dep1);
-		setCoreParameter(liveConfigObjStr + ".DomainName", liveConfigObj.domainName);
-		setCoreParameter(liveConfigObjStr + ".AppName", liveConfigObj.appName);
+		std::string liveConfigObjStr = "LiveConfig." + std::to_string(dep1 + 1);
+		setParameter(liveConfigObjStr + ".DomainName", liveConfigObj.domainName);
+		setParameter(liveConfigObjStr + ".AppName", liveConfigObj.appName);
 	}
 }
 
@@ -62,7 +62,7 @@ int CreateTemplateRequest::getMediaConfig()const
 void CreateTemplateRequest::setMediaConfig(int mediaConfig)
 {
 	mediaConfig_ = mediaConfig;
-	setCoreParameter("MediaConfig", std::to_string(mediaConfig));
+	setParameter("MediaConfig", std::to_string(mediaConfig));
 }
 
 int CreateTemplateRequest::getMaxMixStreamCount()const
@@ -73,7 +73,7 @@ int CreateTemplateRequest::getMaxMixStreamCount()const
 void CreateTemplateRequest::setMaxMixStreamCount(int maxMixStreamCount)
 {
 	maxMixStreamCount_ = maxMixStreamCount;
-	setCoreParameter("MaxMixStreamCount", std::to_string(maxMixStreamCount));
+	setParameter("MaxMixStreamCount", std::to_string(maxMixStreamCount));
 }
 
 std::vector<CreateTemplateRequest::RecordConfig> CreateTemplateRequest::getRecordConfig()const
@@ -86,12 +86,12 @@ void CreateTemplateRequest::setRecordConfig(const std::vector<RecordConfig>& rec
 	recordConfig_ = recordConfig;
 	for(int dep1 = 0; dep1!= recordConfig.size(); dep1++) {
 		auto recordConfigObj = recordConfig.at(dep1);
-		std::string recordConfigObjStr = "RecordConfig." + std::to_string(dep1);
-		setCoreParameter(recordConfigObjStr + ".StorageType", recordConfigObj.storageType);
-		setCoreParameter(recordConfigObjStr + ".FileFormat", std::to_string(recordConfigObj.fileFormat));
-		setCoreParameter(recordConfigObjStr + ".OssEndPoint", recordConfigObj.ossEndPoint);
-		setCoreParameter(recordConfigObjStr + ".OssBucket", recordConfigObj.ossBucket);
-		setCoreParameter(recordConfigObjStr + ".VodTransCodeGroupId", std::to_string(recordConfigObj.vodTransCodeGroupId));
+		std::string recordConfigObjStr = "RecordConfig." + std::to_string(dep1 + 1);
+		setParameter(recordConfigObjStr + ".StorageType", recordConfigObj.storageType);
+		setParameter(recordConfigObjStr + ".FileFormat", std::to_string(recordConfigObj.fileFormat));
+		setParameter(recordConfigObjStr + ".OssEndPoint", recordConfigObj.ossEndPoint);
+		setParameter(recordConfigObjStr + ".OssBucket", recordConfigObj.ossBucket);
+		setParameter(recordConfigObjStr + ".VodTransCodeGroupId", std::to_string(recordConfigObj.vodTransCodeGroupId));
 	}
 }
 
@@ -103,7 +103,7 @@ long CreateTemplateRequest::getOwnerId()const
 void CreateTemplateRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::vector<CreateTemplateRequest::LayOut> CreateTemplateRequest::getLayOut()const
@@ -116,10 +116,10 @@ void CreateTemplateRequest::setLayOut(const std::vector<LayOut>& layOut)
 	layOut_ = layOut;
 	for(int dep1 = 0; dep1!= layOut.size(); dep1++) {
 		auto layOutObj = layOut.at(dep1);
-		std::string layOutObjStr = "LayOut." + std::to_string(dep1);
-		setCoreParameter(layOutObjStr + ".Color", layOutObj.color);
-		setCoreParameter(layOutObjStr + ".CutMode", std::to_string(layOutObj.cutMode));
-		setCoreParameter(layOutObjStr + ".LayOutId", std::to_string(layOutObj.layOutId));
+		std::string layOutObjStr = "LayOut." + std::to_string(dep1 + 1);
+		setParameter(layOutObjStr + ".Color", layOutObj.color);
+		setParameter(layOutObjStr + ".CutMode", std::to_string(layOutObj.cutMode));
+		setParameter(layOutObjStr + ".LayOutId", std::to_string(layOutObj.layOutId));
 	}
 }
 
@@ -131,7 +131,7 @@ std::string CreateTemplateRequest::getAppId()const
 void CreateTemplateRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string CreateTemplateRequest::getCallBack()const
@@ -142,7 +142,7 @@ std::string CreateTemplateRequest::getCallBack()const
 void CreateTemplateRequest::setCallBack(const std::string& callBack)
 {
 	callBack_ = callBack;
-	setCoreParameter("CallBack", callBack);
+	setParameter("CallBack", callBack);
 }
 
 int CreateTemplateRequest::getMixMode()const
@@ -153,6 +153,6 @@ int CreateTemplateRequest::getMixMode()const
 void CreateTemplateRequest::setMixMode(int mixMode)
 {
 	mixMode_ = mixMode;
-	setCoreParameter("MixMode", std::to_string(mixMode));
+	setParameter("MixMode", std::to_string(mixMode));
 }
 

rtc/src/model/DeleteChannelRequest.cc

@@ -35,7 +35,7 @@ long DeleteChannelRequest::getOwnerId()const
 void DeleteChannelRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteChannelRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string DeleteChannelRequest::getAppId()const
 void DeleteChannelRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DeleteChannelRequest::getChannelId()const
@@ -57,6 +57,6 @@ std::string DeleteChannelRequest::getChannelId()const
 void DeleteChannelRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/DeleteConferenceRequest.cc

@@ -35,7 +35,7 @@ std::string DeleteConferenceRequest::getConferenceId()const
 void DeleteConferenceRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 long DeleteConferenceRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long DeleteConferenceRequest::getOwnerId()const
 void DeleteConferenceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteConferenceRequest::getAppId()const
@@ -57,6 +57,6 @@ std::string DeleteConferenceRequest::getAppId()const
 void DeleteConferenceRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/DeleteMAURuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DeleteMAURuleRequest.h>
+
+using AlibabaCloud::Rtc::Model::DeleteMAURuleRequest;
+
+DeleteMAURuleRequest::DeleteMAURuleRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DeleteMAURule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteMAURuleRequest::~DeleteMAURuleRequest()
+{}
+
+long DeleteMAURuleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteMAURuleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteMAURuleRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DeleteMAURuleRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+
+long DeleteMAURuleRequest::getRuleId()const
+{
+	return ruleId_;
+}
+
+void DeleteMAURuleRequest::setRuleId(long ruleId)
+{
+	ruleId_ = ruleId;
+	setParameter("RuleId", std::to_string(ruleId));
+}
+

rtc/src/model/DeleteMAURuleResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DeleteMAURuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+DeleteMAURuleResult::DeleteMAURuleResult() :
+	ServiceResult()
+{}
+
+DeleteMAURuleResult::DeleteMAURuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteMAURuleResult::~DeleteMAURuleResult()
+{}
+
+void DeleteMAURuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

rtc/src/model/DeleteTemplateRequest.cc

@@ -35,7 +35,7 @@ long DeleteTemplateRequest::getOwnerId()const
 void DeleteTemplateRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 long DeleteTemplateRequest::getTemplateId()const
@@ -46,7 +46,7 @@ long DeleteTemplateRequest::getTemplateId()const
 void DeleteTemplateRequest::setTemplateId(long templateId)
 {
 	templateId_ = templateId;
-	setCoreParameter("TemplateId", std::to_string(templateId));
+	setParameter("TemplateId", std::to_string(templateId));
 }
 
 std::string DeleteTemplateRequest::getAppId()const
@@ -57,6 +57,6 @@ std::string DeleteTemplateRequest::getAppId()const
 void DeleteTemplateRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/DescribeAppsRequest.cc

@@ -35,7 +35,7 @@ int DescribeAppsRequest::getPageNum()const
 void DescribeAppsRequest::setPageNum(int pageNum)
 {
 	pageNum_ = pageNum;
-	setCoreParameter("PageNum", std::to_string(pageNum));
+	setParameter("PageNum", std::to_string(pageNum));
 }
 
 int DescribeAppsRequest::getPageSize()const
@@ -46,7 +46,7 @@ int DescribeAppsRequest::getPageSize()const
 void DescribeAppsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeAppsRequest::getOrder()const
@@ -57,7 +57,7 @@ std::string DescribeAppsRequest::getOrder()const
 void DescribeAppsRequest::setOrder(const std::string& order)
 {
 	order_ = order;
-	setCoreParameter("Order", order);
+	setParameter("Order", order);
 }
 
 long DescribeAppsRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeAppsRequest::getOwnerId()const
 void DescribeAppsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeAppsRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeAppsRequest::getAppId()const
 void DescribeAppsRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeAppsRequest::getStatus()const
@@ -90,6 +90,6 @@ std::string DescribeAppsRequest::getStatus()const
 void DescribeAppsRequest::setStatus(const std::string& status)
 {
 	status_ = status;
-	setCoreParameter("Status", status);
+	setParameter("Status", status);
 }
 

rtc/src/model/DescribeChannelParticipantsRequest.cc

@@ -35,7 +35,7 @@ int DescribeChannelParticipantsRequest::getPageNum()const
 void DescribeChannelParticipantsRequest::setPageNum(int pageNum)
 {
 	pageNum_ = pageNum;
-	setCoreParameter("PageNum", std::to_string(pageNum));
+	setParameter("PageNum", std::to_string(pageNum));
 }
 
 int DescribeChannelParticipantsRequest::getPageSize()const
@@ -46,7 +46,7 @@ int DescribeChannelParticipantsRequest::getPageSize()const
 void DescribeChannelParticipantsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeChannelParticipantsRequest::getOrder()const
@@ -57,7 +57,7 @@ std::string DescribeChannelParticipantsRequest::getOrder()const
 void DescribeChannelParticipantsRequest::setOrder(const std::string& order)
 {
 	order_ = order;
-	setCoreParameter("Order", order);
+	setParameter("Order", order);
 }
 
 long DescribeChannelParticipantsRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeChannelParticipantsRequest::getOwnerId()const
 void DescribeChannelParticipantsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeChannelParticipantsRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeChannelParticipantsRequest::getAppId()const
 void DescribeChannelParticipantsRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeChannelParticipantsRequest::getChannelId()const
@@ -90,6 +90,6 @@ std::string DescribeChannelParticipantsRequest::getChannelId()const
 void DescribeChannelParticipantsRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/DescribeConferenceAuthInfoRequest.cc

@@ -35,7 +35,7 @@ long DescribeConferenceAuthInfoRequest::getOwnerId()const
 void DescribeConferenceAuthInfoRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeConferenceAuthInfoRequest::getConferenceId()const
@@ -46,7 +46,7 @@ std::string DescribeConferenceAuthInfoRequest::getConferenceId()const
 void DescribeConferenceAuthInfoRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 std::string DescribeConferenceAuthInfoRequest::getAppId()const
@@ -57,6 +57,6 @@ std::string DescribeConferenceAuthInfoRequest::getAppId()const
 void DescribeConferenceAuthInfoRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/DescribeMAURuleRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeMAURuleRequest.h>
+
+using AlibabaCloud::Rtc::Model::DescribeMAURuleRequest;
+
+DescribeMAURuleRequest::DescribeMAURuleRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DescribeMAURule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMAURuleRequest::~DescribeMAURuleRequest()
+{}
+
+long DescribeMAURuleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeMAURuleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeMAURuleRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DescribeMAURuleRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+

rtc/src/model/DescribeMAURuleResult.cc

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeMAURuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+DescribeMAURuleResult::DescribeMAURuleResult() :
+	ServiceResult()
+{}
+
+DescribeMAURuleResult::DescribeMAURuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMAURuleResult::~DescribeMAURuleResult()
+{}
+
+void DescribeMAURuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRulesNode = value["Rules"]["Rule"];
+	for (auto valueRulesRule : allRulesNode)
+	{
+		Rule rulesObject;
+		if(!valueRulesRule["RuleId"].isNull())
+			rulesObject.ruleId = std::stol(valueRulesRule["RuleId"].asString());
+		if(!valueRulesRule["ChannelPrefix"].isNull())
+			rulesObject.channelPrefix = valueRulesRule["ChannelPrefix"].asString();
+		if(!valueRulesRule["UseridPrefix"].isNull())
+			rulesObject.useridPrefix = valueRulesRule["UseridPrefix"].asString();
+		if(!valueRulesRule["TemplateId"].isNull())
+			rulesObject.templateId = std::stol(valueRulesRule["TemplateId"].asString());
+		if(!valueRulesRule["CallBack"].isNull())
+			rulesObject.callBack = valueRulesRule["CallBack"].asString();
+		if(!valueRulesRule["IsEnable"].isNull())
+			rulesObject.isEnable = std::stoi(valueRulesRule["IsEnable"].asString());
+		rules_.push_back(rulesObject);
+	}
+
+}
+
+std::vector<DescribeMAURuleResult::Rule> DescribeMAURuleResult::getRules()const
+{
+	return rules_;
+}
+

rtc/src/model/DescribeRtcChannelCntDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeRtcChannelCntDataRequest::getStartTime()const
 void DescribeRtcChannelCntDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeRtcChannelCntDataRequest::getServiceArea()const
@@ -46,7 +46,7 @@ std::string DescribeRtcChannelCntDataRequest::getServiceArea()const
 void DescribeRtcChannelCntDataRequest::setServiceArea(const std::string& serviceArea)
 {
 	serviceArea_ = serviceArea;
-	setCoreParameter("ServiceArea", serviceArea);
+	setParameter("ServiceArea", serviceArea);
 }
 
 std::string DescribeRtcChannelCntDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeRtcChannelCntDataRequest::getEndTime()const
 void DescribeRtcChannelCntDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeRtcChannelCntDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeRtcChannelCntDataRequest::getOwnerId()const
 void DescribeRtcChannelCntDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRtcChannelCntDataRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeRtcChannelCntDataRequest::getAppId()const
 void DescribeRtcChannelCntDataRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcChannelCntDataRequest::getInterval()const
@@ -90,6 +90,6 @@ std::string DescribeRtcChannelCntDataRequest::getInterval()const
 void DescribeRtcChannelCntDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

rtc/src/model/DescribeRtcChannelListRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeRtcChannelListRequest::getSortType()const
 void DescribeRtcChannelListRequest::setSortType(const std::string& sortType)
 {
 	sortType_ = sortType;
-	setCoreParameter("SortType", sortType);
+	setParameter("SortType", sortType);
 }
 
 std::string DescribeRtcChannelListRequest::getUserId()const
@@ -46,7 +46,7 @@ std::string DescribeRtcChannelListRequest::getUserId()const
 void DescribeRtcChannelListRequest::setUserId(const std::string& userId)
 {
 	userId_ = userId;
-	setCoreParameter("UserId", userId);
+	setParameter("UserId", userId);
 }
 
 std::string DescribeRtcChannelListRequest::getServiceArea()const
@@ -57,7 +57,7 @@ std::string DescribeRtcChannelListRequest::getServiceArea()const
 void DescribeRtcChannelListRequest::setServiceArea(const std::string& serviceArea)
 {
 	serviceArea_ = serviceArea;
-	setCoreParameter("ServiceArea", serviceArea);
+	setParameter("ServiceArea", serviceArea);
 }
 
 long DescribeRtcChannelListRequest::getPageSize()const
@@ -68,7 +68,7 @@ long DescribeRtcChannelListRequest::getPageSize()const
 void DescribeRtcChannelListRequest::setPageSize(long pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 long DescribeRtcChannelListRequest::getOwnerId()const
@@ -79,7 +79,7 @@ long DescribeRtcChannelListRequest::getOwnerId()const
 void DescribeRtcChannelListRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 long DescribeRtcChannelListRequest::getPageNo()const
@@ -90,7 +90,7 @@ long DescribeRtcChannelListRequest::getPageNo()const
 void DescribeRtcChannelListRequest::setPageNo(long pageNo)
 {
 	pageNo_ = pageNo;
-	setCoreParameter("PageNo", std::to_string(pageNo));
+	setParameter("PageNo", std::to_string(pageNo));
 }
 
 std::string DescribeRtcChannelListRequest::getAppId()const
@@ -101,7 +101,7 @@ std::string DescribeRtcChannelListRequest::getAppId()const
 void DescribeRtcChannelListRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcChannelListRequest::getChannelId()const
@@ -112,7 +112,7 @@ std::string DescribeRtcChannelListRequest::getChannelId()const
 void DescribeRtcChannelListRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 
 std::string DescribeRtcChannelListRequest::getTimePoint()const
@@ -123,6 +123,6 @@ std::string DescribeRtcChannelListRequest::getTimePoint()const
 void DescribeRtcChannelListRequest::setTimePoint(const std::string& timePoint)
 {
 	timePoint_ = timePoint;
-	setCoreParameter("TimePoint", timePoint);
+	setParameter("TimePoint", timePoint);
 }
 

rtc/src/model/DescribeRtcChannelMetricRequest.cc

@@ -35,7 +35,7 @@ long DescribeRtcChannelMetricRequest::getOwnerId()const
 void DescribeRtcChannelMetricRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRtcChannelMetricRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string DescribeRtcChannelMetricRequest::getAppId()const
 void DescribeRtcChannelMetricRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcChannelMetricRequest::getChannelId()const
@@ -57,7 +57,7 @@ std::string DescribeRtcChannelMetricRequest::getChannelId()const
 void DescribeRtcChannelMetricRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 
 std::string DescribeRtcChannelMetricRequest::getTimePoint()const
@@ -68,6 +68,6 @@ std::string DescribeRtcChannelMetricRequest::getTimePoint()const
 void DescribeRtcChannelMetricRequest::setTimePoint(const std::string& timePoint)
 {
 	timePoint_ = timePoint;
-	setCoreParameter("TimePoint", timePoint);
+	setParameter("TimePoint", timePoint);
 }
 

rtc/src/model/DescribeRtcChannelUserListRequest.cc

@@ -35,7 +35,7 @@ long DescribeRtcChannelUserListRequest::getPageSize()const
 void DescribeRtcChannelUserListRequest::setPageSize(long pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 long DescribeRtcChannelUserListRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long DescribeRtcChannelUserListRequest::getOwnerId()const
 void DescribeRtcChannelUserListRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 long DescribeRtcChannelUserListRequest::getPageNo()const
@@ -57,7 +57,7 @@ long DescribeRtcChannelUserListRequest::getPageNo()const
 void DescribeRtcChannelUserListRequest::setPageNo(long pageNo)
 {
 	pageNo_ = pageNo;
-	setCoreParameter("PageNo", std::to_string(pageNo));
+	setParameter("PageNo", std::to_string(pageNo));
 }
 
 std::string DescribeRtcChannelUserListRequest::getAppId()const
@@ -68,7 +68,7 @@ std::string DescribeRtcChannelUserListRequest::getAppId()const
 void DescribeRtcChannelUserListRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcChannelUserListRequest::getChannelId()const
@@ -79,7 +79,7 @@ std::string DescribeRtcChannelUserListRequest::getChannelId()const
 void DescribeRtcChannelUserListRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 
 std::string DescribeRtcChannelUserListRequest::getTimePoint()const
@@ -90,6 +90,6 @@ std::string DescribeRtcChannelUserListRequest::getTimePoint()const
 void DescribeRtcChannelUserListRequest::setTimePoint(const std::string& timePoint)
 {
 	timePoint_ = timePoint;
-	setCoreParameter("TimePoint", timePoint);
+	setParameter("TimePoint", timePoint);
 }
 

rtc/src/model/DescribeRtcDurationDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeRtcDurationDataRequest::getStartTime()const
 void DescribeRtcDurationDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeRtcDurationDataRequest::getServiceArea()const
@@ -46,7 +46,7 @@ std::string DescribeRtcDurationDataRequest::getServiceArea()const
 void DescribeRtcDurationDataRequest::setServiceArea(const std::string& serviceArea)
 {
 	serviceArea_ = serviceArea;
-	setCoreParameter("ServiceArea", serviceArea);
+	setParameter("ServiceArea", serviceArea);
 }
 
 std::string DescribeRtcDurationDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeRtcDurationDataRequest::getEndTime()const
 void DescribeRtcDurationDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeRtcDurationDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeRtcDurationDataRequest::getOwnerId()const
 void DescribeRtcDurationDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRtcDurationDataRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeRtcDurationDataRequest::getAppId()const
 void DescribeRtcDurationDataRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcDurationDataRequest::getInterval()const
@@ -90,6 +90,6 @@ std::string DescribeRtcDurationDataRequest::getInterval()const
 void DescribeRtcDurationDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

rtc/src/model/DescribeRtcPeakChannelCntDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeRtcPeakChannelCntDataRequest::getStartTime()const
 void DescribeRtcPeakChannelCntDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeRtcPeakChannelCntDataRequest::getServiceArea()const
@@ -46,7 +46,7 @@ std::string DescribeRtcPeakChannelCntDataRequest::getServiceArea()const
 void DescribeRtcPeakChannelCntDataRequest::setServiceArea(const std::string& serviceArea)
 {
 	serviceArea_ = serviceArea;
-	setCoreParameter("ServiceArea", serviceArea);
+	setParameter("ServiceArea", serviceArea);
 }
 
 std::string DescribeRtcPeakChannelCntDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeRtcPeakChannelCntDataRequest::getEndTime()const
 void DescribeRtcPeakChannelCntDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeRtcPeakChannelCntDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeRtcPeakChannelCntDataRequest::getOwnerId()const
 void DescribeRtcPeakChannelCntDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRtcPeakChannelCntDataRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeRtcPeakChannelCntDataRequest::getAppId()const
 void DescribeRtcPeakChannelCntDataRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcPeakChannelCntDataRequest::getInterval()const
@@ -90,6 +90,6 @@ std::string DescribeRtcPeakChannelCntDataRequest::getInterval()const
 void DescribeRtcPeakChannelCntDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

rtc/src/model/DescribeRtcPeakUserCntDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeRtcPeakUserCntDataRequest::getStartTime()const
 void DescribeRtcPeakUserCntDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeRtcPeakUserCntDataRequest::getServiceArea()const
@@ -46,7 +46,7 @@ std::string DescribeRtcPeakUserCntDataRequest::getServiceArea()const
 void DescribeRtcPeakUserCntDataRequest::setServiceArea(const std::string& serviceArea)
 {
 	serviceArea_ = serviceArea;
-	setCoreParameter("ServiceArea", serviceArea);
+	setParameter("ServiceArea", serviceArea);
 }
 
 std::string DescribeRtcPeakUserCntDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeRtcPeakUserCntDataRequest::getEndTime()const
 void DescribeRtcPeakUserCntDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeRtcPeakUserCntDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeRtcPeakUserCntDataRequest::getOwnerId()const
 void DescribeRtcPeakUserCntDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRtcPeakUserCntDataRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeRtcPeakUserCntDataRequest::getAppId()const
 void DescribeRtcPeakUserCntDataRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcPeakUserCntDataRequest::getInterval()const
@@ -90,6 +90,6 @@ std::string DescribeRtcPeakUserCntDataRequest::getInterval()const
 void DescribeRtcPeakUserCntDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

rtc/src/model/DescribeRtcQualityMetricRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeRtcQualityMetricRequest.h>
+
+using AlibabaCloud::Rtc::Model::DescribeRtcQualityMetricRequest;
+
+DescribeRtcQualityMetricRequest::DescribeRtcQualityMetricRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DescribeRtcQualityMetric")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRtcQualityMetricRequest::~DescribeRtcQualityMetricRequest()
+{}
+
+std::string DescribeRtcQualityMetricRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeRtcQualityMetricRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeRtcQualityMetricRequest::getSubUser()const
+{
+	return subUser_;
+}
+
+void DescribeRtcQualityMetricRequest::setSubUser(const std::string& subUser)
+{
+	subUser_ = subUser;
+	setParameter("SubUser", subUser);
+}
+
+std::string DescribeRtcQualityMetricRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeRtcQualityMetricRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeRtcQualityMetricRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeRtcQualityMetricRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeRtcQualityMetricRequest::getPubUser()const
+{
+	return pubUser_;
+}
+
+void DescribeRtcQualityMetricRequest::setPubUser(const std::string& pubUser)
+{
+	pubUser_ = pubUser;
+	setParameter("PubUser", pubUser);
+}
+
+std::string DescribeRtcQualityMetricRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DescribeRtcQualityMetricRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+
+std::string DescribeRtcQualityMetricRequest::getChannelId()const
+{
+	return channelId_;
+}
+
+void DescribeRtcQualityMetricRequest::setChannelId(const std::string& channelId)
+{
+	channelId_ = channelId;
+	setParameter("ChannelId", channelId);
+}
+

rtc/src/model/DescribeRtcQualityMetricResult.cc

@@ -0,0 +1,190 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeRtcQualityMetricResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+DescribeRtcQualityMetricResult::DescribeRtcQualityMetricResult() :
+	ServiceResult()
+{}
+
+DescribeRtcQualityMetricResult::DescribeRtcQualityMetricResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRtcQualityMetricResult::~DescribeRtcQualityMetricResult()
+{}
+
+void DescribeRtcQualityMetricResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto qualityMetricNode = value["QualityMetric"];
+	auto subInfoNode = qualityMetricNode["SubInfo"];
+	auto allDataNode = subInfoNode["Data"]["DataItem"];
+	for (auto subInfoNodeDataDataItem : allDataNode)
+	{
+		QualityMetric::SubInfo::DataItem dataItemObject;
+		if(!subInfoNodeDataDataItem["Time"].isNull())
+			dataItemObject.time = subInfoNodeDataDataItem["Time"].asString();
+		auto fpsNode = value["Fps"];
+		if(!fpsNode["Small"].isNull())
+			dataItemObject.fps.small = std::stol(fpsNode["Small"].asString());
+		if(!fpsNode["Large"].isNull())
+			dataItemObject.fps.large = std::stol(fpsNode["Large"].asString());
+		if(!fpsNode["Super"].isNull())
+			dataItemObject.fps.super = std::stol(fpsNode["Super"].asString());
+		if(!fpsNode["Share"].isNull())
+			dataItemObject.fps.share = std::stol(fpsNode["Share"].asString());
+		auto resolutionNode = value["Resolution"];
+		if(!resolutionNode["Small"].isNull())
+			dataItemObject.resolution.small = std::stol(resolutionNode["Small"].asString());
+		if(!resolutionNode["Large"].isNull())
+			dataItemObject.resolution.large = std::stol(resolutionNode["Large"].asString());
+		if(!resolutionNode["Super"].isNull())
+			dataItemObject.resolution.super = std::stol(resolutionNode["Super"].asString());
+		if(!resolutionNode["Share"].isNull())
+			dataItemObject.resolution.share = std::stol(resolutionNode["Share"].asString());
+		auto bitRateNode = value["BitRate"];
+		if(!bitRateNode["Audio"].isNull())
+			dataItemObject.bitRate.audio = std::stol(bitRateNode["Audio"].asString());
+		if(!bitRateNode["Small"].isNull())
+			dataItemObject.bitRate.small = std::stol(bitRateNode["Small"].asString());
+		if(!bitRateNode["Large"].isNull())
+			dataItemObject.bitRate.large = std::stol(bitRateNode["Large"].asString());
+		if(!bitRateNode["Super"].isNull())
+			dataItemObject.bitRate.super = std::stol(bitRateNode["Super"].asString());
+		if(!bitRateNode["Share"].isNull())
+			dataItemObject.bitRate.share = std::stol(bitRateNode["Share"].asString());
+		auto networkNode = value["Network"];
+		if(!networkNode["Loss"].isNull())
+			dataItemObject.network.loss = std::stof(networkNode["Loss"].asString());
+		if(!networkNode["Rtt"].isNull())
+			dataItemObject.network.rtt = std::stol(networkNode["Rtt"].asString());
+		qualityMetric_.subInfo.data.push_back(dataItemObject);
+	}
+	auto allEventsNode = subInfoNode["Events"]["EventsItem"];
+	for (auto subInfoNodeEventsEventsItem : allEventsNode)
+	{
+		QualityMetric::SubInfo::EventsItem eventsItemObject;
+		if(!subInfoNodeEventsEventsItem["Time"].isNull())
+			eventsItemObject.time = subInfoNodeEventsEventsItem["Time"].asString();
+		if(!subInfoNodeEventsEventsItem["EventId"].isNull())
+			eventsItemObject.eventId = std::stol(subInfoNodeEventsEventsItem["EventId"].asString());
+		if(!subInfoNodeEventsEventsItem["Name"].isNull())
+			eventsItemObject.name = subInfoNodeEventsEventsItem["Name"].asString();
+		if(!subInfoNodeEventsEventsItem["Category"].isNull())
+			eventsItemObject.category = subInfoNodeEventsEventsItem["Category"].asString();
+		if(!subInfoNodeEventsEventsItem["Result"].isNull())
+			eventsItemObject.result = subInfoNodeEventsEventsItem["Result"].asString();
+		if(!subInfoNodeEventsEventsItem["Description"].isNull())
+			eventsItemObject.description = subInfoNodeEventsEventsItem["Description"].asString();
+		qualityMetric_.subInfo.events.push_back(eventsItemObject);
+	}
+	auto userNode = subInfoNode["User"];
+	if(!userNode["UserId"].isNull())
+		qualityMetric_.subInfo.user.userId = userNode["UserId"].asString();
+	if(!userNode["SDKVersion"].isNull())
+		qualityMetric_.subInfo.user.sDKVersion = userNode["SDKVersion"].asString();
+	if(!userNode["OS"].isNull())
+		qualityMetric_.subInfo.user.oS = userNode["OS"].asString();
+	if(!userNode["Province"].isNull())
+		qualityMetric_.subInfo.user.province = userNode["Province"].asString();
+	auto pubInfoNode = qualityMetricNode["PubInfo"];
+	auto allData2Node = pubInfoNode["Data"]["DataItem"];
+	for (auto pubInfoNodeDataDataItem : allData2Node)
+	{
+		QualityMetric::PubInfo::DataItem4 dataItem4Object;
+		if(!pubInfoNodeDataDataItem["Time"].isNull())
+			dataItem4Object.time = pubInfoNodeDataDataItem["Time"].asString();
+		auto fps5Node = value["Fps"];
+		if(!fps5Node["Small"].isNull())
+			dataItem4Object.fps5.small = std::stol(fps5Node["Small"].asString());
+		if(!fps5Node["Large"].isNull())
+			dataItem4Object.fps5.large = std::stol(fps5Node["Large"].asString());
+		if(!fps5Node["Super"].isNull())
+			dataItem4Object.fps5.super = std::stol(fps5Node["Super"].asString());
+		if(!fps5Node["Share"].isNull())
+			dataItem4Object.fps5.share = std::stol(fps5Node["Share"].asString());
+		auto resolution6Node = value["Resolution"];
+		if(!resolution6Node["Small"].isNull())
+			dataItem4Object.resolution6.small = std::stol(resolution6Node["Small"].asString());
+		if(!resolution6Node["Large"].isNull())
+			dataItem4Object.resolution6.large = std::stol(resolution6Node["Large"].asString());
+		if(!resolution6Node["Super"].isNull())
+			dataItem4Object.resolution6.super = std::stol(resolution6Node["Super"].asString());
+		if(!resolution6Node["Share"].isNull())
+			dataItem4Object.resolution6.share = std::stol(resolution6Node["Share"].asString());
+		auto bitRate7Node = value["BitRate"];
+		if(!bitRate7Node["Audio"].isNull())
+			dataItem4Object.bitRate7.audio = std::stol(bitRate7Node["Audio"].asString());
+		if(!bitRate7Node["Small"].isNull())
+			dataItem4Object.bitRate7.small = std::stol(bitRate7Node["Small"].asString());
+		if(!bitRate7Node["Large"].isNull())
+			dataItem4Object.bitRate7.large = std::stol(bitRate7Node["Large"].asString());
+		if(!bitRate7Node["Super"].isNull())
+			dataItem4Object.bitRate7.super = std::stol(bitRate7Node["Super"].asString());
+		if(!bitRate7Node["Share"].isNull())
+			dataItem4Object.bitRate7.share = std::stol(bitRate7Node["Share"].asString());
+		auto network8Node = value["Network"];
+		if(!network8Node["Loss"].isNull())
+			dataItem4Object.network8.loss = std::stof(network8Node["Loss"].asString());
+		if(!network8Node["Rtt"].isNull())
+			dataItem4Object.network8.rtt = std::stol(network8Node["Rtt"].asString());
+		qualityMetric_.pubInfo.data2.push_back(dataItem4Object);
+	}
+	auto allEvents3Node = pubInfoNode["Events"]["EventsItem"];
+	for (auto pubInfoNodeEventsEventsItem : allEvents3Node)
+	{
+		QualityMetric::PubInfo::EventsItem9 eventsItem9Object;
+		if(!pubInfoNodeEventsEventsItem["Time"].isNull())
+			eventsItem9Object.time = pubInfoNodeEventsEventsItem["Time"].asString();
+		if(!pubInfoNodeEventsEventsItem["EventId"].isNull())
+			eventsItem9Object.eventId = std::stol(pubInfoNodeEventsEventsItem["EventId"].asString());
+		if(!pubInfoNodeEventsEventsItem["Name"].isNull())
+			eventsItem9Object.name = pubInfoNodeEventsEventsItem["Name"].asString();
+		if(!pubInfoNodeEventsEventsItem["Category"].isNull())
+			eventsItem9Object.category = pubInfoNodeEventsEventsItem["Category"].asString();
+		if(!pubInfoNodeEventsEventsItem["Result"].isNull())
+			eventsItem9Object.result = pubInfoNodeEventsEventsItem["Result"].asString();
+		if(!pubInfoNodeEventsEventsItem["Description"].isNull())
+			eventsItem9Object.description = pubInfoNodeEventsEventsItem["Description"].asString();
+		qualityMetric_.pubInfo.events3.push_back(eventsItem9Object);
+	}
+	auto user1Node = pubInfoNode["User"];
+	if(!user1Node["UserId"].isNull())
+		qualityMetric_.pubInfo.user1.userId = user1Node["UserId"].asString();
+	if(!user1Node["SDKVersion"].isNull())
+		qualityMetric_.pubInfo.user1.sDKVersion = user1Node["SDKVersion"].asString();
+	if(!user1Node["OS"].isNull())
+		qualityMetric_.pubInfo.user1.oS = user1Node["OS"].asString();
+	if(!user1Node["Province"].isNull())
+		qualityMetric_.pubInfo.user1.province = user1Node["Province"].asString();
+
+}
+
+DescribeRtcQualityMetricResult::QualityMetric DescribeRtcQualityMetricResult::getQualityMetric()const
+{
+	return qualityMetric_;
+}
+

rtc/src/model/DescribeRtcUserCntDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeRtcUserCntDataRequest::getStartTime()const
 void DescribeRtcUserCntDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeRtcUserCntDataRequest::getServiceArea()const
@@ -46,7 +46,7 @@ std::string DescribeRtcUserCntDataRequest::getServiceArea()const
 void DescribeRtcUserCntDataRequest::setServiceArea(const std::string& serviceArea)
 {
 	serviceArea_ = serviceArea;
-	setCoreParameter("ServiceArea", serviceArea);
+	setParameter("ServiceArea", serviceArea);
 }
 
 std::string DescribeRtcUserCntDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeRtcUserCntDataRequest::getEndTime()const
 void DescribeRtcUserCntDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeRtcUserCntDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeRtcUserCntDataRequest::getOwnerId()const
 void DescribeRtcUserCntDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeRtcUserCntDataRequest::getAppId()const
@@ -79,7 +79,7 @@ std::string DescribeRtcUserCntDataRequest::getAppId()const
 void DescribeRtcUserCntDataRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string DescribeRtcUserCntDataRequest::getInterval()const
@@ -90,6 +90,6 @@ std::string DescribeRtcUserCntDataRequest::getInterval()const
 void DescribeRtcUserCntDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

rtc/src/model/DescribeRtcUserListRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeRtcUserListRequest.h>
+
+using AlibabaCloud::Rtc::Model::DescribeRtcUserListRequest;
+
+DescribeRtcUserListRequest::DescribeRtcUserListRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DescribeRtcUserList")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRtcUserListRequest::~DescribeRtcUserListRequest()
+{}
+
+std::string DescribeRtcUserListRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeRtcUserListRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeRtcUserListRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeRtcUserListRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeRtcUserListRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeRtcUserListRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeRtcUserListRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DescribeRtcUserListRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+
+std::string DescribeRtcUserListRequest::getChannelId()const
+{
+	return channelId_;
+}
+
+void DescribeRtcUserListRequest::setChannelId(const std::string& channelId)
+{
+	channelId_ = channelId;
+	setParameter("ChannelId", channelId);
+}
+

rtc/src/model/DescribeRtcUserListResult.cc

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DescribeRtcUserListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+DescribeRtcUserListResult::DescribeRtcUserListResult() :
+	ServiceResult()
+{}
+
+DescribeRtcUserListResult::DescribeRtcUserListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRtcUserListResult::~DescribeRtcUserListResult()
+{}
+
+void DescribeRtcUserListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allUserListNode = value["UserList"]["UserListItem"];
+	for (auto valueUserListUserListItem : allUserListNode)
+	{
+		UserListItem userListObject;
+		if(!valueUserListUserListItem["User"].isNull())
+			userListObject.user = valueUserListUserListItem["User"].asString();
+		userList_.push_back(userListObject);
+	}
+
+}
+
+std::vector<DescribeRtcUserListResult::UserListItem> DescribeRtcUserListResult::getUserList()const
+{
+	return userList_;
+}
+

rtc/src/model/DisableMAURuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DisableMAURuleRequest.h>
+
+using AlibabaCloud::Rtc::Model::DisableMAURuleRequest;
+
+DisableMAURuleRequest::DisableMAURuleRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "DisableMAURule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DisableMAURuleRequest::~DisableMAURuleRequest()
+{}
+
+long DisableMAURuleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DisableMAURuleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DisableMAURuleRequest::getAppId()const
+{
+	return appId_;
+}
+
+void DisableMAURuleRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+
+long DisableMAURuleRequest::getRuleId()const
+{
+	return ruleId_;
+}
+
+void DisableMAURuleRequest::setRuleId(long ruleId)
+{
+	ruleId_ = ruleId;
+	setParameter("RuleId", std::to_string(ruleId));
+}
+

rtc/src/model/DisableMAURuleResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/DisableMAURuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+DisableMAURuleResult::DisableMAURuleResult() :
+	ServiceResult()
+{}
+
+DisableMAURuleResult::DisableMAURuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DisableMAURuleResult::~DisableMAURuleResult()
+{}
+
+void DisableMAURuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

rtc/src/model/EnableMAURuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/EnableMAURuleRequest.h>
+
+using AlibabaCloud::Rtc::Model::EnableMAURuleRequest;
+
+EnableMAURuleRequest::EnableMAURuleRequest() :
+	RpcServiceRequest("rtc", "2018-01-11", "EnableMAURule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnableMAURuleRequest::~EnableMAURuleRequest()
+{}
+
+long EnableMAURuleRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void EnableMAURuleRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string EnableMAURuleRequest::getAppId()const
+{
+	return appId_;
+}
+
+void EnableMAURuleRequest::setAppId(const std::string& appId)
+{
+	appId_ = appId;
+	setParameter("AppId", appId);
+}
+
+long EnableMAURuleRequest::getRuleId()const
+{
+	return ruleId_;
+}
+
+void EnableMAURuleRequest::setRuleId(long ruleId)
+{
+	ruleId_ = ruleId;
+	setParameter("RuleId", std::to_string(ruleId));
+}
+

rtc/src/model/EnableMAURuleResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/rtc/model/EnableMAURuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rtc;
+using namespace AlibabaCloud::Rtc::Model;
+
+EnableMAURuleResult::EnableMAURuleResult() :
+	ServiceResult()
+{}
+
+EnableMAURuleResult::EnableMAURuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnableMAURuleResult::~EnableMAURuleResult()
+{}
+
+void EnableMAURuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

rtc/src/model/GetMPUTaskStatusRequest.cc

@@ -35,7 +35,7 @@ long GetMPUTaskStatusRequest::getOwnerId()const
 void GetMPUTaskStatusRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string GetMPUTaskStatusRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string GetMPUTaskStatusRequest::getAppId()const
 void GetMPUTaskStatusRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string GetMPUTaskStatusRequest::getTaskId()const
@@ -57,6 +57,6 @@ std::string GetMPUTaskStatusRequest::getTaskId()const
 void GetMPUTaskStatusRequest::setTaskId(const std::string& taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", taskId);
+	setParameter("TaskId", taskId);
 }
 

rtc/src/model/GetTaskStatusRequest.cc

@@ -35,7 +35,7 @@ long GetTaskStatusRequest::getOwnerId()const
 void GetTaskStatusRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string GetTaskStatusRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string GetTaskStatusRequest::getAppId()const
 void GetTaskStatusRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string GetTaskStatusRequest::getChannelId()const
@@ -57,7 +57,7 @@ std::string GetTaskStatusRequest::getChannelId()const
 void GetTaskStatusRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 
 long GetTaskStatusRequest::getTaskId()const
@@ -68,6 +68,6 @@ long GetTaskStatusRequest::getTaskId()const
 void GetTaskStatusRequest::setTaskId(long taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", std::to_string(taskId));
+	setParameter("TaskId", std::to_string(taskId));
 }
 

rtc/src/model/ModifyAppRequest.cc

@@ -35,7 +35,7 @@ long ModifyAppRequest::getOwnerId()const
 void ModifyAppRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyAppRequest::getAppName()const
@@ -46,7 +46,7 @@ std::string ModifyAppRequest::getAppName()const
 void ModifyAppRequest::setAppName(const std::string& appName)
 {
 	appName_ = appName;
-	setCoreParameter("AppName", appName);
+	setParameter("AppName", appName);
 }
 
 std::string ModifyAppRequest::getAppId()const
@@ -57,6 +57,6 @@ std::string ModifyAppRequest::getAppId()const
 void ModifyAppRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/ModifyConferenceRequest.cc

@@ -35,7 +35,7 @@ std::string ModifyConferenceRequest::getStartTime()const
 void ModifyConferenceRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string ModifyConferenceRequest::getType()const
@@ -46,7 +46,7 @@ std::string ModifyConferenceRequest::getType()const
 void ModifyConferenceRequest::setType(const std::string& type)
 {
 	type_ = type;
-	setCoreParameter("Type", type);
+	setParameter("Type", type);
 }
 
 std::string ModifyConferenceRequest::getConferenceId()const
@@ -57,7 +57,7 @@ std::string ModifyConferenceRequest::getConferenceId()const
 void ModifyConferenceRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 std::string ModifyConferenceRequest::getConferenceName()const
@@ -68,7 +68,7 @@ std::string ModifyConferenceRequest::getConferenceName()const
 void ModifyConferenceRequest::setConferenceName(const std::string& conferenceName)
 {
 	conferenceName_ = conferenceName;
-	setCoreParameter("ConferenceName", conferenceName);
+	setParameter("ConferenceName", conferenceName);
 }
 
 long ModifyConferenceRequest::getOwnerId()const
@@ -79,7 +79,7 @@ long ModifyConferenceRequest::getOwnerId()const
 void ModifyConferenceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ModifyConferenceRequest::getAppId()const
@@ -90,7 +90,7 @@ std::string ModifyConferenceRequest::getAppId()const
 void ModifyConferenceRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 int ModifyConferenceRequest::getRemindNotice()const
@@ -101,6 +101,6 @@ int ModifyConferenceRequest::getRemindNotice()const
 void ModifyConferenceRequest::setRemindNotice(int remindNotice)
 {
 	remindNotice_ = remindNotice;
-	setCoreParameter("RemindNotice", std::to_string(remindNotice));
+	setParameter("RemindNotice", std::to_string(remindNotice));
 }
 

rtc/src/model/MuteAudioAllRequest.cc

@@ -35,7 +35,7 @@ std::string MuteAudioAllRequest::getConferenceId()const
 void MuteAudioAllRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 long MuteAudioAllRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long MuteAudioAllRequest::getOwnerId()const
 void MuteAudioAllRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string MuteAudioAllRequest::getParticipantId()const
@@ -57,7 +57,7 @@ std::string MuteAudioAllRequest::getParticipantId()const
 void MuteAudioAllRequest::setParticipantId(const std::string& participantId)
 {
 	participantId_ = participantId;
-	setCoreParameter("ParticipantId", participantId);
+	setParameter("ParticipantId", participantId);
 }
 
 std::string MuteAudioAllRequest::getAppId()const
@@ -68,6 +68,6 @@ std::string MuteAudioAllRequest::getAppId()const
 void MuteAudioAllRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/MuteAudioRequest.cc

@@ -36,7 +36,7 @@ void MuteAudioRequest::setParticipantIds(const std::vector<std::string>& partici
 {
 	participantIds_ = participantIds;
 	for(int dep1 = 0; dep1!= participantIds.size(); dep1++) {
-		setCoreParameter("ParticipantIds."+ std::to_string(dep1), participantIds.at(dep1));
+		setParameter("ParticipantIds."+ std::to_string(dep1), participantIds.at(dep1));
 	}
 }
 
@@ -48,7 +48,7 @@ std::string MuteAudioRequest::getConferenceId()const
 void MuteAudioRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 long MuteAudioRequest::getOwnerId()const
@@ -59,7 +59,7 @@ long MuteAudioRequest::getOwnerId()const
 void MuteAudioRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string MuteAudioRequest::getAppId()const
@@ -70,6 +70,6 @@ std::string MuteAudioRequest::getAppId()const
 void MuteAudioRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/ReceiveNotifyRequest.cc

@@ -35,7 +35,7 @@ std::string ReceiveNotifyRequest::getTraceId()const
 void ReceiveNotifyRequest::setTraceId(const std::string& traceId)
 {
 	traceId_ = traceId;
-	setCoreParameter("TraceId", traceId);
+	setParameter("TraceId", traceId);
 }
 
 std::string ReceiveNotifyRequest::getContent()const
@@ -46,7 +46,7 @@ std::string ReceiveNotifyRequest::getContent()const
 void ReceiveNotifyRequest::setContent(const std::string& content)
 {
 	content_ = content;
-	setCoreParameter("Content", content);
+	setParameter("Content", content);
 }
 
 std::string ReceiveNotifyRequest::getEvent()const
@@ -57,7 +57,7 @@ std::string ReceiveNotifyRequest::getEvent()const
 void ReceiveNotifyRequest::setEvent(const std::string& event)
 {
 	event_ = event;
-	setCoreParameter("Event", event);
+	setParameter("Event", event);
 }
 
 long ReceiveNotifyRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long ReceiveNotifyRequest::getOwnerId()const
 void ReceiveNotifyRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string ReceiveNotifyRequest::getContentType()const
@@ -79,7 +79,7 @@ std::string ReceiveNotifyRequest::getContentType()const
 void ReceiveNotifyRequest::setContentType(const std::string& contentType)
 {
 	contentType_ = contentType;
-	setCoreParameter("ContentType", contentType);
+	setParameter("ContentType", contentType);
 }
 
 std::string ReceiveNotifyRequest::getBizId()const
@@ -90,6 +90,6 @@ std::string ReceiveNotifyRequest::getBizId()const
 void ReceiveNotifyRequest::setBizId(const std::string& bizId)
 {
 	bizId_ = bizId;
-	setCoreParameter("BizId", bizId);
+	setParameter("BizId", bizId);
 }
 

rtc/src/model/RemoveParticipantsRequest.cc

@@ -36,7 +36,7 @@ void RemoveParticipantsRequest::setParticipantIds(const std::vector<std::string>
 {
 	participantIds_ = participantIds;
 	for(int dep1 = 0; dep1!= participantIds.size(); dep1++) {
-		setCoreParameter("ParticipantIds."+ std::to_string(dep1), participantIds.at(dep1));
+		setParameter("ParticipantIds."+ std::to_string(dep1), participantIds.at(dep1));
 	}
 }
 
@@ -48,7 +48,7 @@ long RemoveParticipantsRequest::getOwnerId()const
 void RemoveParticipantsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string RemoveParticipantsRequest::getConferenceId()const
@@ -59,7 +59,7 @@ std::string RemoveParticipantsRequest::getConferenceId()const
 void RemoveParticipantsRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 std::string RemoveParticipantsRequest::getAppId()const
@@ -70,6 +70,6 @@ std::string RemoveParticipantsRequest::getAppId()const
 void RemoveParticipantsRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/RemoveTerminalsRequest.cc

@@ -36,7 +36,7 @@ void RemoveTerminalsRequest::setTerminalIds(const std::vector<std::string>& term
 {
 	terminalIds_ = terminalIds;
 	for(int dep1 = 0; dep1!= terminalIds.size(); dep1++) {
-		setCoreParameter("TerminalIds."+ std::to_string(dep1), terminalIds.at(dep1));
+		setParameter("TerminalIds."+ std::to_string(dep1), terminalIds.at(dep1));
 	}
 }
 
@@ -48,7 +48,7 @@ long RemoveTerminalsRequest::getOwnerId()const
 void RemoveTerminalsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string RemoveTerminalsRequest::getAppId()const
@@ -59,7 +59,7 @@ std::string RemoveTerminalsRequest::getAppId()const
 void RemoveTerminalsRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string RemoveTerminalsRequest::getChannelId()const
@@ -70,6 +70,6 @@ std::string RemoveTerminalsRequest::getChannelId()const
 void RemoveTerminalsRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/StartMPUTaskRequest.cc

@@ -37,10 +37,10 @@ void StartMPUTaskRequest::setUserPanes(const std::vector<UserPanes>& userPanes)
 	userPanes_ = userPanes;
 	for(int dep1 = 0; dep1!= userPanes.size(); dep1++) {
 		auto userPanesObj = userPanes.at(dep1);
-		std::string userPanesObjStr = "UserPanes." + std::to_string(dep1);
-		setCoreParameter(userPanesObjStr + ".PaneId", std::to_string(userPanesObj.paneId));
-		setCoreParameter(userPanesObjStr + ".UserId", userPanesObj.userId);
-		setCoreParameter(userPanesObjStr + ".SourceType", userPanesObj.sourceType);
+		std::string userPanesObjStr = "UserPanes." + std::to_string(dep1 + 1);
+		setParameter(userPanesObjStr + ".PaneId", std::to_string(userPanesObj.paneId));
+		setParameter(userPanesObjStr + ".UserId", userPanesObj.userId);
+		setParameter(userPanesObjStr + ".SourceType", userPanesObj.sourceType);
 	}
 }
 
@@ -52,7 +52,7 @@ int StartMPUTaskRequest::getBackgroundColor()const
 void StartMPUTaskRequest::setBackgroundColor(int backgroundColor)
 {
 	backgroundColor_ = backgroundColor;
-	setCoreParameter("BackgroundColor", std::to_string(backgroundColor));
+	setParameter("BackgroundColor", std::to_string(backgroundColor));
 }
 
 int StartMPUTaskRequest::getCropMode()const
@@ -63,7 +63,7 @@ int StartMPUTaskRequest::getCropMode()const
 void StartMPUTaskRequest::setCropMode(int cropMode)
 {
 	cropMode_ = cropMode;
-	setCoreParameter("CropMode", std::to_string(cropMode));
+	setParameter("CropMode", std::to_string(cropMode));
 }
 
 std::string StartMPUTaskRequest::getTaskProfile()const
@@ -74,7 +74,7 @@ std::string StartMPUTaskRequest::getTaskProfile()const
 void StartMPUTaskRequest::setTaskProfile(const std::string& taskProfile)
 {
 	taskProfile_ = taskProfile;
-	setCoreParameter("TaskProfile", taskProfile);
+	setParameter("TaskProfile", taskProfile);
 }
 
 std::vector<long> StartMPUTaskRequest::getLayoutIds()const
@@ -86,7 +86,7 @@ void StartMPUTaskRequest::setLayoutIds(const std::vector<long>& layoutIds)
 {
 	layoutIds_ = layoutIds;
 	for(int dep1 = 0; dep1!= layoutIds.size(); dep1++) {
-		setCoreParameter("LayoutIds."+ std::to_string(dep1), std::to_string(layoutIds.at(dep1)));
+		setParameter("LayoutIds."+ std::to_string(dep1), std::to_string(layoutIds.at(dep1)));
 	}
 }
 
@@ -98,7 +98,7 @@ std::string StartMPUTaskRequest::getTaskId()const
 void StartMPUTaskRequest::setTaskId(const std::string& taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", taskId);
+	setParameter("TaskId", taskId);
 }
 
 std::string StartMPUTaskRequest::getStreamURL()const
@@ -109,7 +109,7 @@ std::string StartMPUTaskRequest::getStreamURL()const
 void StartMPUTaskRequest::setStreamURL(const std::string& streamURL)
 {
 	streamURL_ = streamURL;
-	setCoreParameter("StreamURL", streamURL);
+	setParameter("StreamURL", streamURL);
 }
 
 long StartMPUTaskRequest::getOwnerId()const
@@ -120,7 +120,7 @@ long StartMPUTaskRequest::getOwnerId()const
 void StartMPUTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::vector<std::string> StartMPUTaskRequest::getSubSpecUsers()const
@@ -132,7 +132,7 @@ void StartMPUTaskRequest::setSubSpecUsers(const std::vector<std::string>& subSpe
 {
 	subSpecUsers_ = subSpecUsers;
 	for(int dep1 = 0; dep1!= subSpecUsers.size(); dep1++) {
-		setCoreParameter("SubSpecUsers."+ std::to_string(dep1), subSpecUsers.at(dep1));
+		setParameter("SubSpecUsers."+ std::to_string(dep1), subSpecUsers.at(dep1));
 	}
 }
 
@@ -144,7 +144,7 @@ std::string StartMPUTaskRequest::getAppId()const
 void StartMPUTaskRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 int StartMPUTaskRequest::getMediaEncode()const
@@ -155,7 +155,7 @@ int StartMPUTaskRequest::getMediaEncode()const
 void StartMPUTaskRequest::setMediaEncode(int mediaEncode)
 {
 	mediaEncode_ = mediaEncode;
-	setCoreParameter("MediaEncode", std::to_string(mediaEncode));
+	setParameter("MediaEncode", std::to_string(mediaEncode));
 }
 
 std::string StartMPUTaskRequest::getChannelId()const
@@ -166,6 +166,6 @@ std::string StartMPUTaskRequest::getChannelId()const
 void StartMPUTaskRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/StartTaskRequest.cc

@@ -37,10 +37,10 @@ void StartTaskRequest::setMixPanes(const std::vector<MixPanes>& mixPanes)
 	mixPanes_ = mixPanes;
 	for(int dep1 = 0; dep1!= mixPanes.size(); dep1++) {
 		auto mixPanesObj = mixPanes.at(dep1);
-		std::string mixPanesObjStr = "MixPanes." + std::to_string(dep1);
-		setCoreParameter(mixPanesObjStr + ".PaneId", std::to_string(mixPanesObj.paneId));
-		setCoreParameter(mixPanesObjStr + ".UserId", mixPanesObj.userId);
-		setCoreParameter(mixPanesObjStr + ".SourceType", mixPanesObj.sourceType);
+		std::string mixPanesObjStr = "MixPanes." + std::to_string(dep1 + 1);
+		setParameter(mixPanesObjStr + ".PaneId", std::to_string(mixPanesObj.paneId));
+		setParameter(mixPanesObjStr + ".UserId", mixPanesObj.userId);
+		setParameter(mixPanesObjStr + ".SourceType", mixPanesObj.sourceType);
 	}
 }
 
@@ -52,7 +52,7 @@ std::string StartTaskRequest::getIdempotentId()const
 void StartTaskRequest::setIdempotentId(const std::string& idempotentId)
 {
 	idempotentId_ = idempotentId;
-	setCoreParameter("IdempotentId", idempotentId);
+	setParameter("IdempotentId", idempotentId);
 }
 
 long StartTaskRequest::getOwnerId()const
@@ -63,7 +63,7 @@ long StartTaskRequest::getOwnerId()const
 void StartTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 long StartTaskRequest::getTemplateId()const
@@ -74,7 +74,7 @@ long StartTaskRequest::getTemplateId()const
 void StartTaskRequest::setTemplateId(long templateId)
 {
 	templateId_ = templateId;
-	setCoreParameter("TemplateId", std::to_string(templateId));
+	setParameter("TemplateId", std::to_string(templateId));
 }
 
 std::string StartTaskRequest::getAppId()const
@@ -85,7 +85,7 @@ std::string StartTaskRequest::getAppId()const
 void StartTaskRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string StartTaskRequest::getChannelId()const
@@ -96,6 +96,6 @@ std::string StartTaskRequest::getChannelId()const
 void StartTaskRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/StopMPUTaskRequest.cc

@@ -35,7 +35,7 @@ long StopMPUTaskRequest::getOwnerId()const
 void StopMPUTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string StopMPUTaskRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string StopMPUTaskRequest::getAppId()const
 void StopMPUTaskRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string StopMPUTaskRequest::getTaskId()const
@@ -57,6 +57,6 @@ std::string StopMPUTaskRequest::getTaskId()const
 void StopMPUTaskRequest::setTaskId(const std::string& taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", taskId);
+	setParameter("TaskId", taskId);
 }
 

rtc/src/model/StopTaskRequest.cc

@@ -35,7 +35,7 @@ long StopTaskRequest::getOwnerId()const
 void StopTaskRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string StopTaskRequest::getAppId()const
@@ -46,7 +46,7 @@ std::string StopTaskRequest::getAppId()const
 void StopTaskRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string StopTaskRequest::getChannelId()const
@@ -57,7 +57,7 @@ std::string StopTaskRequest::getChannelId()const
 void StopTaskRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 
 long StopTaskRequest::getTaskId()const
@@ -68,6 +68,6 @@ long StopTaskRequest::getTaskId()const
 void StopTaskRequest::setTaskId(long taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", std::to_string(taskId));
+	setParameter("TaskId", std::to_string(taskId));
 }
 

rtc/src/model/UnmuteAudioAllRequest.cc

@@ -35,7 +35,7 @@ std::string UnmuteAudioAllRequest::getConferenceId()const
 void UnmuteAudioAllRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 long UnmuteAudioAllRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long UnmuteAudioAllRequest::getOwnerId()const
 void UnmuteAudioAllRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string UnmuteAudioAllRequest::getParticipantId()const
@@ -57,7 +57,7 @@ std::string UnmuteAudioAllRequest::getParticipantId()const
 void UnmuteAudioAllRequest::setParticipantId(const std::string& participantId)
 {
 	participantId_ = participantId;
-	setCoreParameter("ParticipantId", participantId);
+	setParameter("ParticipantId", participantId);
 }
 
 std::string UnmuteAudioAllRequest::getAppId()const
@@ -68,6 +68,6 @@ std::string UnmuteAudioAllRequest::getAppId()const
 void UnmuteAudioAllRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/UnmuteAudioRequest.cc

@@ -36,7 +36,7 @@ void UnmuteAudioRequest::setParticipantIds(const std::vector<std::string>& parti
 {
 	participantIds_ = participantIds;
 	for(int dep1 = 0; dep1!= participantIds.size(); dep1++) {
-		setCoreParameter("ParticipantIds."+ std::to_string(dep1), participantIds.at(dep1));
+		setParameter("ParticipantIds."+ std::to_string(dep1), participantIds.at(dep1));
 	}
 }
 
@@ -48,7 +48,7 @@ std::string UnmuteAudioRequest::getConferenceId()const
 void UnmuteAudioRequest::setConferenceId(const std::string& conferenceId)
 {
 	conferenceId_ = conferenceId;
-	setCoreParameter("ConferenceId", conferenceId);
+	setParameter("ConferenceId", conferenceId);
 }
 
 long UnmuteAudioRequest::getOwnerId()const
@@ -59,7 +59,7 @@ long UnmuteAudioRequest::getOwnerId()const
 void UnmuteAudioRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string UnmuteAudioRequest::getAppId()const
@@ -70,6 +70,6 @@ std::string UnmuteAudioRequest::getAppId()const
 void UnmuteAudioRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 

rtc/src/model/UpdateChannelRequest.cc

@@ -35,7 +35,7 @@ long UpdateChannelRequest::getOwnerId()const
 void UpdateChannelRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string UpdateChannelRequest::getNonce()const
@@ -46,7 +46,7 @@ std::string UpdateChannelRequest::getNonce()const
 void UpdateChannelRequest::setNonce(const std::string& nonce)
 {
 	nonce_ = nonce;
-	setCoreParameter("Nonce", nonce);
+	setParameter("Nonce", nonce);
 }
 
 std::string UpdateChannelRequest::getAppId()const
@@ -57,7 +57,7 @@ std::string UpdateChannelRequest::getAppId()const
 void UpdateChannelRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }
 
 std::string UpdateChannelRequest::getChannelId()const
@@ -68,6 +68,6 @@ std::string UpdateChannelRequest::getChannelId()const
 void UpdateChannelRequest::setChannelId(const std::string& channelId)
 {
 	channelId_ = channelId;
-	setCoreParameter("ChannelId", channelId);
+	setParameter("ChannelId", channelId);
 }
 

rtc/src/model/UpdateMPULayoutRequest.cc

@@ -37,10 +37,10 @@ void UpdateMPULayoutRequest::setUserPanes(const std::vector<UserPanes>& userPane
 	userPanes_ = userPanes;
 	for(int dep1 = 0; dep1!= userPanes.size(); dep1++) {
 		auto userPanesObj = userPanes.at(dep1);
-		std::string userPanesObjStr = "UserPanes." + std::to_string(dep1);
-		setCoreParameter(userPanesObjStr + ".PaneId", std::to_string(userPanesObj.paneId));
-		setCoreParameter(userPanesObjStr + ".UserId", userPanesObj.userId);
-		setCoreParameter(userPanesObjStr + ".SourceType", userPanesObj.sourceType);
+		std::string userPanesObjStr = "UserPanes." + std::to_string(dep1 + 1);
+		setParameter(userPanesObjStr + ".PaneId", std::to_string(userPanesObj.paneId));
+		setParameter(userPanesObjStr + ".UserId", userPanesObj.userId);
+		setParameter(userPanesObjStr + ".SourceType", userPanesObj.sourceType);
 	}
 }
 
@@ -52,7 +52,7 @@ int UpdateMPULayoutRequest::getBackgroundColor()const
 void UpdateMPULayoutRequest::setBackgroundColor(int backgroundColor)
 {
 	backgroundColor_ = backgroundColor;
-	setCoreParameter("BackgroundColor", std::to_string(backgroundColor));
+	setParameter("BackgroundColor", std::to_string(backgroundColor));
 }
 
 int UpdateMPULayoutRequest::getCropMode()const
@@ -63,7 +63,7 @@ int UpdateMPULayoutRequest::getCropMode()const
 void UpdateMPULayoutRequest::setCropMode(int cropMode)
 {
 	cropMode_ = cropMode;
-	setCoreParameter("CropMode", std::to_string(cropMode));
+	setParameter("CropMode", std::to_string(cropMode));
 }
 
 std::vector<long> UpdateMPULayoutRequest::getLayoutIds()const
@@ -75,7 +75,7 @@ void UpdateMPULayoutRequest::setLayoutIds(const std::vector<long>& layoutIds)
 {
 	layoutIds_ = layoutIds;
 	for(int dep1 = 0; dep1!= layoutIds.size(); dep1++) {
-		setCoreParameter("LayoutIds."+ std::to_string(dep1), std::to_string(layoutIds.at(dep1)));
+		setParameter("LayoutIds."+ std::to_string(dep1), std::to_string(layoutIds.at(dep1)));
 	}
 }
 
@@ -87,7 +87,7 @@ std::string UpdateMPULayoutRequest::getTaskId()const
 void UpdateMPULayoutRequest::setTaskId(const std::string& taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", taskId);
+	setParameter("TaskId", taskId);
 }
 
 long UpdateMPULayoutRequest::getOwnerId()const
@@ -98,7 +98,7 @@ long UpdateMPULayoutRequest::getOwnerId()const
 void UpdateMPULayoutRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string UpdateMPULayoutRequest::getAppId()const
@@ -109,6 +109,6 @@ std::string UpdateMPULayoutRequest::getAppId()const
 void UpdateMPULayoutRequest::setAppId(const std::string& appId)
 {
 	appId_ = appId;
-	setCoreParameter("AppId", appId);
+	setParameter("AppId", appId);
 }