Update to support new apis.

VERSION

@@ -1 +1 @@
-1.36.1867
+1.36.1868

live/CMakeLists.txt

@@ -331,6 +331,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainMonitoringUsageDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainOnlineUserNumRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainOnlineUserNumResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainPublishErrorCodeRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainPublishErrorCodeResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainPushBpsDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainPushBpsDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainPushTrafficDataRequest.h
@@ -471,6 +473,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveTagResourcesResult.h
 	include/alibabacloud/live/model/DescribeLiveTopDomainsByFlowRequest.h
 	include/alibabacloud/live/model/DescribeLiveTopDomainsByFlowResult.h
+	include/alibabacloud/live/model/DescribeLiveUpVideoAudioInfoRequest.h
+	include/alibabacloud/live/model/DescribeLiveUpVideoAudioInfoResult.h
 	include/alibabacloud/live/model/DescribeLiveUserBillPredictionRequest.h
 	include/alibabacloud/live/model/DescribeLiveUserBillPredictionResult.h
 	include/alibabacloud/live/model/DescribeLiveUserDomainsRequest.h
@@ -597,6 +601,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/ListMessageGroupUserResult.h
 	include/alibabacloud/live/model/ListMessageGroupUserByIdRequest.h
 	include/alibabacloud/live/model/ListMessageGroupUserByIdResult.h
+	include/alibabacloud/live/model/ListMuteGroupUserRequest.h
+	include/alibabacloud/live/model/ListMuteGroupUserResult.h
 	include/alibabacloud/live/model/ListPlaylistRequest.h
 	include/alibabacloud/live/model/ListPlaylistResult.h
 	include/alibabacloud/live/model/ListPlaylistItemsRequest.h
@@ -1106,6 +1112,8 @@ set(live_src
 	src/model/DescribeLiveDomainMonitoringUsageDataResult.cc
 	src/model/DescribeLiveDomainOnlineUserNumRequest.cc
 	src/model/DescribeLiveDomainOnlineUserNumResult.cc
+	src/model/DescribeLiveDomainPublishErrorCodeRequest.cc
+	src/model/DescribeLiveDomainPublishErrorCodeResult.cc
 	src/model/DescribeLiveDomainPushBpsDataRequest.cc
 	src/model/DescribeLiveDomainPushBpsDataResult.cc
 	src/model/DescribeLiveDomainPushTrafficDataRequest.cc
@@ -1246,6 +1254,8 @@ set(live_src
 	src/model/DescribeLiveTagResourcesResult.cc
 	src/model/DescribeLiveTopDomainsByFlowRequest.cc
 	src/model/DescribeLiveTopDomainsByFlowResult.cc
+	src/model/DescribeLiveUpVideoAudioInfoRequest.cc
+	src/model/DescribeLiveUpVideoAudioInfoResult.cc
 	src/model/DescribeLiveUserBillPredictionRequest.cc
 	src/model/DescribeLiveUserBillPredictionResult.cc
 	src/model/DescribeLiveUserDomainsRequest.cc
@@ -1372,6 +1382,8 @@ set(live_src
 	src/model/ListMessageGroupUserResult.cc
 	src/model/ListMessageGroupUserByIdRequest.cc
 	src/model/ListMessageGroupUserByIdResult.cc
+	src/model/ListMuteGroupUserRequest.cc
+	src/model/ListMuteGroupUserResult.cc
 	src/model/ListPlaylistRequest.cc
 	src/model/ListPlaylistResult.cc
 	src/model/ListPlaylistItemsRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -332,6 +332,8 @@
 #include "model/DescribeLiveDomainMonitoringUsageDataResult.h"
 #include "model/DescribeLiveDomainOnlineUserNumRequest.h"
 #include "model/DescribeLiveDomainOnlineUserNumResult.h"
+#include "model/DescribeLiveDomainPublishErrorCodeRequest.h"
+#include "model/DescribeLiveDomainPublishErrorCodeResult.h"
 #include "model/DescribeLiveDomainPushBpsDataRequest.h"
 #include "model/DescribeLiveDomainPushBpsDataResult.h"
 #include "model/DescribeLiveDomainPushTrafficDataRequest.h"
@@ -472,6 +474,8 @@
 #include "model/DescribeLiveTagResourcesResult.h"
 #include "model/DescribeLiveTopDomainsByFlowRequest.h"
 #include "model/DescribeLiveTopDomainsByFlowResult.h"
+#include "model/DescribeLiveUpVideoAudioInfoRequest.h"
+#include "model/DescribeLiveUpVideoAudioInfoResult.h"
 #include "model/DescribeLiveUserBillPredictionRequest.h"
 #include "model/DescribeLiveUserBillPredictionResult.h"
 #include "model/DescribeLiveUserDomainsRequest.h"
@@ -598,6 +602,8 @@
 #include "model/ListMessageGroupUserResult.h"
 #include "model/ListMessageGroupUserByIdRequest.h"
 #include "model/ListMessageGroupUserByIdResult.h"
+#include "model/ListMuteGroupUserRequest.h"
+#include "model/ListMuteGroupUserResult.h"
 #include "model/ListPlaylistRequest.h"
 #include "model/ListPlaylistResult.h"
 #include "model/ListPlaylistItemsRequest.h"
@@ -1268,6 +1274,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainOnlineUserNumResult> DescribeLiveDomainOnlineUserNumOutcome;
 			typedef std::future<DescribeLiveDomainOnlineUserNumOutcome> DescribeLiveDomainOnlineUserNumOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainOnlineUserNumRequest&, const DescribeLiveDomainOnlineUserNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainOnlineUserNumAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainPublishErrorCodeResult> DescribeLiveDomainPublishErrorCodeOutcome;
+			typedef std::future<DescribeLiveDomainPublishErrorCodeOutcome> DescribeLiveDomainPublishErrorCodeOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainPublishErrorCodeRequest&, const DescribeLiveDomainPublishErrorCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainPublishErrorCodeAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainPushBpsDataResult> DescribeLiveDomainPushBpsDataOutcome;
 			typedef std::future<DescribeLiveDomainPushBpsDataOutcome> DescribeLiveDomainPushBpsDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainPushBpsDataRequest&, const DescribeLiveDomainPushBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainPushBpsDataAsyncHandler;
@@ -1478,6 +1487,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveTopDomainsByFlowResult> DescribeLiveTopDomainsByFlowOutcome;
 			typedef std::future<DescribeLiveTopDomainsByFlowOutcome> DescribeLiveTopDomainsByFlowOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveTopDomainsByFlowRequest&, const DescribeLiveTopDomainsByFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveTopDomainsByFlowAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveUpVideoAudioInfoResult> DescribeLiveUpVideoAudioInfoOutcome;
+			typedef std::future<DescribeLiveUpVideoAudioInfoOutcome> DescribeLiveUpVideoAudioInfoOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveUpVideoAudioInfoRequest&, const DescribeLiveUpVideoAudioInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveUpVideoAudioInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveUserBillPredictionResult> DescribeLiveUserBillPredictionOutcome;
 			typedef std::future<DescribeLiveUserBillPredictionOutcome> DescribeLiveUserBillPredictionOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveUserBillPredictionRequest&, const DescribeLiveUserBillPredictionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveUserBillPredictionAsyncHandler;
@@ -1667,6 +1679,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListMessageGroupUserByIdResult> ListMessageGroupUserByIdOutcome;
 			typedef std::future<ListMessageGroupUserByIdOutcome> ListMessageGroupUserByIdOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::ListMessageGroupUserByIdRequest&, const ListMessageGroupUserByIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListMessageGroupUserByIdAsyncHandler;
+			typedef Outcome<Error, Model::ListMuteGroupUserResult> ListMuteGroupUserOutcome;
+			typedef std::future<ListMuteGroupUserOutcome> ListMuteGroupUserOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::ListMuteGroupUserRequest&, const ListMuteGroupUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListMuteGroupUserAsyncHandler;
 			typedef Outcome<Error, Model::ListPlaylistResult> ListPlaylistOutcome;
 			typedef std::future<ListPlaylistOutcome> ListPlaylistOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::ListPlaylistRequest&, const ListPlaylistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPlaylistAsyncHandler;
@@ -2431,6 +2446,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainOnlineUserNumOutcome describeLiveDomainOnlineUserNum(const Model::DescribeLiveDomainOnlineUserNumRequest &request)const;
 			void describeLiveDomainOnlineUserNumAsync(const Model::DescribeLiveDomainOnlineUserNumRequest& request, const DescribeLiveDomainOnlineUserNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainOnlineUserNumOutcomeCallable describeLiveDomainOnlineUserNumCallable(const Model::DescribeLiveDomainOnlineUserNumRequest& request) const;
+			DescribeLiveDomainPublishErrorCodeOutcome describeLiveDomainPublishErrorCode(const Model::DescribeLiveDomainPublishErrorCodeRequest &request)const;
+			void describeLiveDomainPublishErrorCodeAsync(const Model::DescribeLiveDomainPublishErrorCodeRequest& request, const DescribeLiveDomainPublishErrorCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainPublishErrorCodeOutcomeCallable describeLiveDomainPublishErrorCodeCallable(const Model::DescribeLiveDomainPublishErrorCodeRequest& request) const;
 			DescribeLiveDomainPushBpsDataOutcome describeLiveDomainPushBpsData(const Model::DescribeLiveDomainPushBpsDataRequest &request)const;
 			void describeLiveDomainPushBpsDataAsync(const Model::DescribeLiveDomainPushBpsDataRequest& request, const DescribeLiveDomainPushBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainPushBpsDataOutcomeCallable describeLiveDomainPushBpsDataCallable(const Model::DescribeLiveDomainPushBpsDataRequest& request) const;
@@ -2641,6 +2659,9 @@ namespace AlibabaCloud
 			DescribeLiveTopDomainsByFlowOutcome describeLiveTopDomainsByFlow(const Model::DescribeLiveTopDomainsByFlowRequest &request)const;
 			void describeLiveTopDomainsByFlowAsync(const Model::DescribeLiveTopDomainsByFlowRequest& request, const DescribeLiveTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveTopDomainsByFlowOutcomeCallable describeLiveTopDomainsByFlowCallable(const Model::DescribeLiveTopDomainsByFlowRequest& request) const;
+			DescribeLiveUpVideoAudioInfoOutcome describeLiveUpVideoAudioInfo(const Model::DescribeLiveUpVideoAudioInfoRequest &request)const;
+			void describeLiveUpVideoAudioInfoAsync(const Model::DescribeLiveUpVideoAudioInfoRequest& request, const DescribeLiveUpVideoAudioInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveUpVideoAudioInfoOutcomeCallable describeLiveUpVideoAudioInfoCallable(const Model::DescribeLiveUpVideoAudioInfoRequest& request) const;
 			DescribeLiveUserBillPredictionOutcome describeLiveUserBillPrediction(const Model::DescribeLiveUserBillPredictionRequest &request)const;
 			void describeLiveUserBillPredictionAsync(const Model::DescribeLiveUserBillPredictionRequest& request, const DescribeLiveUserBillPredictionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveUserBillPredictionOutcomeCallable describeLiveUserBillPredictionCallable(const Model::DescribeLiveUserBillPredictionRequest& request) const;
@@ -2830,6 +2851,9 @@ namespace AlibabaCloud
 			ListMessageGroupUserByIdOutcome listMessageGroupUserById(const Model::ListMessageGroupUserByIdRequest &request)const;
 			void listMessageGroupUserByIdAsync(const Model::ListMessageGroupUserByIdRequest& request, const ListMessageGroupUserByIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListMessageGroupUserByIdOutcomeCallable listMessageGroupUserByIdCallable(const Model::ListMessageGroupUserByIdRequest& request) const;
+			ListMuteGroupUserOutcome listMuteGroupUser(const Model::ListMuteGroupUserRequest &request)const;
+			void listMuteGroupUserAsync(const Model::ListMuteGroupUserRequest& request, const ListMuteGroupUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListMuteGroupUserOutcomeCallable listMuteGroupUserCallable(const Model::ListMuteGroupUserRequest& request) const;
 			ListPlaylistOutcome listPlaylist(const Model::ListPlaylistRequest &request)const;
 			void listPlaylistAsync(const Model::ListPlaylistRequest& request, const ListPlaylistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListPlaylistOutcomeCallable listPlaylistCallable(const Model::ListPlaylistRequest& request) const;

live/include/alibabacloud/live/model/CreateLiveMessageAppResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 				CreateLiveMessageAppResult();
 				explicit CreateLiveMessageAppResult(const std::string &payload);
 				~CreateLiveMessageAppResult();
+				std::string getDataCenter()const;
 				std::string getAppId()const;
 				std::string getAppKey()const;
 				std::string getAppSign()const;
@@ -44,6 +45,7 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string dataCenter_;
 				std::string appId_;
 				std::string appKey_;
 				std::string appSign_;

live/include/alibabacloud/live/model/DescribeLiveCdnDiagnoseInfoRequest.h

@@ -38,6 +38,8 @@ public:
 	void setStartTime(long startTime);
 	std::string getRequestType() const;
 	void setRequestType(const std::string &requestType);
+	std::string getSecurityToken() const;
+	void setSecurityToken(const std::string &securityToken);
 	std::string getStreamName() const;
 	void setStreamName(const std::string &streamName);
 	std::string getApp() const;
@@ -54,6 +56,7 @@ private:
 	std::string streamSuffix_;
 	long startTime_;
 	std::string requestType_;
+	std::string securityToken_;
 	std::string streamName_;
 	std::string app_;
 	int phase_;

live/include/alibabacloud/live/model/DescribeLiveDomainPublishErrorCodeRequest.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_LIVE_MODEL_DESCRIBELIVEDOMAINPUBLISHERRORCODEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINPUBLISHERRORCODEREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainPublishErrorCodeRequest : public RpcServiceRequest {
+public:
+	DescribeLiveDomainPublishErrorCodeRequest();
+	~DescribeLiveDomainPublishErrorCodeRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string startTime_;
+	std::string appName_;
+	std::string domainName_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINPUBLISHERRORCODEREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainPublishErrorCodeResult.h

@@ -0,0 +1,70 @@
+/*
+ * 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_LIVE_MODEL_DESCRIBELIVEDOMAINPUBLISHERRORCODERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINPUBLISHERRORCODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainPublishErrorCodeResult : public ServiceResult
+			{
+			public:
+				struct Rtcd
+				{
+					struct Cd
+					{
+						std::string proportion;
+						std::string count;
+						std::string code;
+					};
+					std::vector<Rtcd::Cd> codeData;
+					std::string timeStamp;
+				};
+
+
+				DescribeLiveDomainPublishErrorCodeResult();
+				explicit DescribeLiveDomainPublishErrorCodeResult(const std::string &payload);
+				~DescribeLiveDomainPublishErrorCodeResult();
+				std::string getEndTime()const;
+				std::string getDomainName()const;
+				std::string getDataInterval()const;
+				std::string getStartTime()const;
+				std::vector<Rtcd> getRealTimeCodeData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string domainName_;
+				std::string dataInterval_;
+				std::string startTime_;
+				std::vector<Rtcd> realTimeCodeData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINPUBLISHERRORCODERESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainTranscodeParamsRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeLiveDomainTranscodeParamsRequest();
 	std::string getPushdomain() const;
 	void setPushdomain(const std::string &pushdomain);
+	std::string getSecurityToken() const;
+	void setSecurityToken(const std::string &securityToken);
 	std::string getApp() const;
 	void setApp(const std::string &app);
 	std::string getTemplate_name() const;
@@ -39,6 +41,7 @@ public:
 
 private:
 	std::string pushdomain_;
+	std::string securityToken_;
 	std::string app_;
 	std::string template_name_;
 };

live/include/alibabacloud/live/model/DescribeLiveUpVideoAudioInfoRequest.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_LIVE_MODEL_DESCRIBELIVEUPVIDEOAUDIOINFOREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEUPVIDEOAUDIOINFOREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT DescribeLiveUpVideoAudioInfoRequest : public RpcServiceRequest {
+public:
+	DescribeLiveUpVideoAudioInfoRequest();
+	~DescribeLiveUpVideoAudioInfoRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getStream() const;
+	void setStream(const std::string &stream);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string startTime_;
+	std::string stream_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEUPVIDEOAUDIOINFOREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveUpVideoAudioInfoResult.h

@@ -0,0 +1,136 @@
+/*
+ * 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_LIVE_MODEL_DESCRIBELIVEUPVIDEOAUDIOINFORESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEUPVIDEOAUDIOINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveUpVideoAudioInfoResult : public ServiceResult
+			{
+			public:
+				struct PublishItem
+				{
+					struct VideoFramesItem
+					{
+						int value;
+						long time;
+					};
+					struct AudioFramesItem
+					{
+						int value;
+						long time;
+					};
+					struct VideoStampsItem
+					{
+						int value;
+						long time;
+					};
+					struct AudioStampsItem
+					{
+						int value;
+						long time;
+					};
+					struct V_AStamp
+					{
+						int value;
+						long time;
+					};
+					struct AvcHeadersItem
+					{
+						int value;
+						long time;
+					};
+					struct AacHeadersItem
+					{
+						int value;
+						long time;
+					};
+					struct VideoBitRateItem
+					{
+						int value;
+						long time;
+					};
+					struct AudioBitRateItem
+					{
+						int value;
+						long time;
+					};
+					struct VideoIntervalItem
+					{
+						int value;
+						long time;
+					};
+					struct AudioIntervalItem
+					{
+						int value;
+						long time;
+					};
+					struct ErrorFlagsItem
+					{
+						int value;
+						long time;
+					};
+					std::vector<PublishItem::VideoStampsItem> videoStamps;
+					std::vector<PublishItem::VideoFramesItem> videoFrames;
+					std::vector<PublishItem::AudioBitRateItem> audioBitRate;
+					std::string publishIp;
+					std::string uniqueId;
+					std::string domainName;
+					std::vector<PublishItem::AacHeadersItem> aacHeaders;
+					std::vector<PublishItem::AudioIntervalItem> audioInterval;
+					std::vector<PublishItem::ErrorFlagsItem> errorFlags;
+					std::vector<PublishItem::VideoBitRateItem> videoBitRate;
+					std::string codecInfo;
+					std::vector<PublishItem::AudioFramesItem> audioFrames;
+					std::string appName;
+					std::string publishInterval;
+					std::string streamName;
+					std::vector<PublishItem::VideoIntervalItem> videoInterval;
+					std::vector<PublishItem::AudioStampsItem> audioStamps;
+					std::string publishTime;
+					std::vector<PublishItem::V_AStamp> videoAndAudioStamp;
+					std::vector<PublishItem::AvcHeadersItem> avcHeaders;
+					std::string publishStatus;
+					std::string stopTime;
+				};
+
+
+				DescribeLiveUpVideoAudioInfoResult();
+				explicit DescribeLiveUpVideoAudioInfoResult(const std::string &payload);
+				~DescribeLiveUpVideoAudioInfoResult();
+				std::vector<PublishItem> getUpItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PublishItem> upItems_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEUPVIDEOAUDIOINFORESULT_H_

live/include/alibabacloud/live/model/ListLiveMessageGroupMessagesRequest.h

@@ -34,6 +34,10 @@ public:
 	void setSortType(int sortType);
 	long getNextPageToken() const;
 	void setNextPageToken(long nextPageToken);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	long getMsgType() const;
+	void setMsgType(long msgType);
 	std::string getGroupId() const;
 	void setGroupId(const std::string &groupId);
 	long getEndTime() const;
@@ -44,21 +48,17 @@ public:
 	void setDataCenter(const std::string &dataCenter);
 	std::string getAppId() const;
 	void setAppId(const std::string &appId);
-	int getPageSize() const;
-	void setPageSize(int pageSize);
-	long getMsgType() const;
-	void setMsgType(long msgType);
 
 private:
 	int sortType_;
 	long nextPageToken_;
+	int pageSize_;
+	long msgType_;
 	std::string groupId_;
 	long endTime_;
 	long beginTime_;
 	std::string dataCenter_;
 	std::string appId_;
-	int pageSize_;
-	long msgType_;
 };
 } // namespace Model
 } // namespace Live

live/include/alibabacloud/live/model/ListMuteGroupUserRequest.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_LIVE_MODEL_LISTMUTEGROUPUSERREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_LISTMUTEGROUPUSERREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT ListMuteGroupUserRequest : public RpcServiceRequest {
+public:
+	ListMuteGroupUserRequest();
+	~ListMuteGroupUserRequest();
+	int getPageNum() const;
+	void setPageNum(int pageNum);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getOperatorUserId() const;
+	void setOperatorUserId(const std::string &operatorUserId);
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+
+private:
+	int pageNum_;
+	int pageSize_;
+	std::string operatorUserId_;
+	std::string groupId_;
+	std::string appId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_LISTMUTEGROUPUSERREQUEST_H_

live/include/alibabacloud/live/model/ListMuteGroupUserResult.h

@@ -0,0 +1,61 @@
+/*
+ * 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_LIVE_MODEL_LISTMUTEGROUPUSERRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_LISTMUTEGROUPUSERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT ListMuteGroupUserResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct UserListItem
+					{
+						std::string userId;
+					};
+					bool hasMore;
+					int total;
+					std::vector<UserListItem> userList;
+				};
+
+
+				ListMuteGroupUserResult();
+				explicit ListMuteGroupUserResult(const std::string &payload);
+				~ListMuteGroupUserResult();
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_LISTMUTEGROUPUSERRESULT_H_

live/include/alibabacloud/live/model/StartLiveMPUTaskRequest.h

@@ -34,15 +34,15 @@ public:
 		std::string userId;
 	};
 	struct SeiParams {
+		std::string payloadType;
 		struct LayoutVolume {
 			std::string followIdr;
-			std::string payloadType;
 			std::string interval;
 		};
 		LayoutVolume layoutVolume;
 		struct PassThrough {
 			std::string followIdr;
-			std::string payloadType;
+			std::string payloadContentKey;
 			std::string payloadContent;
 			std::string interval;
 		};

live/include/alibabacloud/live/model/UpdateLiveMPUTaskRequest.h

@@ -36,13 +36,12 @@ public:
 	struct SeiParams {
 		struct LayoutVolume {
 			std::string followIdr;
-			std::string payloadType;
 			std::string interval;
 		};
 		LayoutVolume layoutVolume;
 		struct PassThrough {
 			std::string followIdr;
-			std::string payloadType;
+			std::string payloadContentKey;
 			std::string payloadContent;
 			std::string interval;
 		};

live/src/LiveClient.cc

@@ -5631,6 +5631,42 @@ LiveClient::DescribeLiveDomainOnlineUserNumOutcomeCallable LiveClient::describeL
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainPublishErrorCodeOutcome LiveClient::describeLiveDomainPublishErrorCode(const DescribeLiveDomainPublishErrorCodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainPublishErrorCodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainPublishErrorCodeOutcome(DescribeLiveDomainPublishErrorCodeResult(outcome.result()));
+	else
+		return DescribeLiveDomainPublishErrorCodeOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainPublishErrorCodeAsync(const DescribeLiveDomainPublishErrorCodeRequest& request, const DescribeLiveDomainPublishErrorCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainPublishErrorCode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainPublishErrorCodeOutcomeCallable LiveClient::describeLiveDomainPublishErrorCodeCallable(const DescribeLiveDomainPublishErrorCodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainPublishErrorCodeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainPublishErrorCode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainPushBpsDataOutcome LiveClient::describeLiveDomainPushBpsData(const DescribeLiveDomainPushBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8151,6 +8187,42 @@ LiveClient::DescribeLiveTopDomainsByFlowOutcomeCallable LiveClient::describeLive
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveUpVideoAudioInfoOutcome LiveClient::describeLiveUpVideoAudioInfo(const DescribeLiveUpVideoAudioInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveUpVideoAudioInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveUpVideoAudioInfoOutcome(DescribeLiveUpVideoAudioInfoResult(outcome.result()));
+	else
+		return DescribeLiveUpVideoAudioInfoOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveUpVideoAudioInfoAsync(const DescribeLiveUpVideoAudioInfoRequest& request, const DescribeLiveUpVideoAudioInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveUpVideoAudioInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveUpVideoAudioInfoOutcomeCallable LiveClient::describeLiveUpVideoAudioInfoCallable(const DescribeLiveUpVideoAudioInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveUpVideoAudioInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveUpVideoAudioInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveUserBillPredictionOutcome LiveClient::describeLiveUserBillPrediction(const DescribeLiveUserBillPredictionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10419,6 +10491,42 @@ LiveClient::ListMessageGroupUserByIdOutcomeCallable LiveClient::listMessageGroup
 	return task->get_future();
 }
 
+LiveClient::ListMuteGroupUserOutcome LiveClient::listMuteGroupUser(const ListMuteGroupUserRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListMuteGroupUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListMuteGroupUserOutcome(ListMuteGroupUserResult(outcome.result()));
+	else
+		return ListMuteGroupUserOutcome(outcome.error());
+}
+
+void LiveClient::listMuteGroupUserAsync(const ListMuteGroupUserRequest& request, const ListMuteGroupUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listMuteGroupUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::ListMuteGroupUserOutcomeCallable LiveClient::listMuteGroupUserCallable(const ListMuteGroupUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListMuteGroupUserOutcome()>>(
+			[this, request]()
+			{
+			return this->listMuteGroupUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::ListPlaylistOutcome LiveClient::listPlaylist(const ListPlaylistRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/CreateLiveMessageAppResult.cc

@@ -45,9 +45,16 @@ void CreateLiveMessageAppResult::parse(const std::string &payload)
 		appKey_ = value["AppKey"].asString();
 	if(!value["AppSign"].isNull())
 		appSign_ = value["AppSign"].asString();
+	if(!value["DataCenter"].isNull())
+		dataCenter_ = value["DataCenter"].asString();
 
 }
 
+std::string CreateLiveMessageAppResult::getDataCenter()const
+{
+	return dataCenter_;
+}
+
 std::string CreateLiveMessageAppResult::getAppId()const
 {
 	return appId_;

live/src/model/DescribeLiveCdnDiagnoseInfoRequest.cc

@@ -61,6 +61,15 @@ void DescribeLiveCdnDiagnoseInfoRequest::setRequestType(const std::string &reque
   setParameter(std::string("requestType"), requestType);
 }
 
+std::string DescribeLiveCdnDiagnoseInfoRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void DescribeLiveCdnDiagnoseInfoRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
 std::string DescribeLiveCdnDiagnoseInfoRequest::getStreamName() const {
   return streamName_;
 }

live/src/model/DescribeLiveDomainPublishErrorCodeRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/live/model/DescribeLiveDomainPublishErrorCodeRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainPublishErrorCodeRequest;
+
+DescribeLiveDomainPublishErrorCodeRequest::DescribeLiveDomainPublishErrorCodeRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainPublishErrorCode") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainPublishErrorCodeRequest::~DescribeLiveDomainPublishErrorCodeRequest() {}
+
+std::string DescribeLiveDomainPublishErrorCodeRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeLiveDomainPublishErrorCodeRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeLiveDomainPublishErrorCodeRequest::getAppName() const {
+  return appName_;
+}
+
+void DescribeLiveDomainPublishErrorCodeRequest::setAppName(const std::string &appName) {
+  appName_ = appName;
+  setParameter(std::string("AppName"), appName);
+}
+
+std::string DescribeLiveDomainPublishErrorCodeRequest::getDomainName() const {
+  return domainName_;
+}
+
+void DescribeLiveDomainPublishErrorCodeRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+std::string DescribeLiveDomainPublishErrorCodeRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeLiveDomainPublishErrorCodeRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+long DescribeLiveDomainPublishErrorCodeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLiveDomainPublishErrorCodeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveDomainPublishErrorCodeResult.cc

@@ -0,0 +1,97 @@
+/*
+ * 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/live/model/DescribeLiveDomainPublishErrorCodeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainPublishErrorCodeResult::DescribeLiveDomainPublishErrorCodeResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainPublishErrorCodeResult::DescribeLiveDomainPublishErrorCodeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainPublishErrorCodeResult::~DescribeLiveDomainPublishErrorCodeResult()
+{}
+
+void DescribeLiveDomainPublishErrorCodeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeCodeDataNode = value["RealTimeCodeData"]["rtcd"];
+	for (auto valueRealTimeCodeDatartcd : allRealTimeCodeDataNode)
+	{
+		Rtcd realTimeCodeDataObject;
+		if(!valueRealTimeCodeDatartcd["TimeStamp"].isNull())
+			realTimeCodeDataObject.timeStamp = valueRealTimeCodeDatartcd["TimeStamp"].asString();
+		auto allCodeDataNode = valueRealTimeCodeDatartcd["CodeData"]["cd"];
+		for (auto valueRealTimeCodeDatartcdCodeDatacd : allCodeDataNode)
+		{
+			Rtcd::Cd codeDataObject;
+			if(!valueRealTimeCodeDatartcdCodeDatacd["Code"].isNull())
+				codeDataObject.code = valueRealTimeCodeDatartcdCodeDatacd["Code"].asString();
+			if(!valueRealTimeCodeDatartcdCodeDatacd["Count"].isNull())
+				codeDataObject.count = valueRealTimeCodeDatartcdCodeDatacd["Count"].asString();
+			if(!valueRealTimeCodeDatartcdCodeDatacd["Proportion"].isNull())
+				codeDataObject.proportion = valueRealTimeCodeDatartcdCodeDatacd["Proportion"].asString();
+			realTimeCodeDataObject.codeData.push_back(codeDataObject);
+		}
+		realTimeCodeData_.push_back(realTimeCodeDataObject);
+	}
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+
+}
+
+std::string DescribeLiveDomainPublishErrorCodeResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeLiveDomainPublishErrorCodeResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeLiveDomainPublishErrorCodeResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::string DescribeLiveDomainPublishErrorCodeResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeLiveDomainPublishErrorCodeResult::Rtcd> DescribeLiveDomainPublishErrorCodeResult::getRealTimeCodeData()const
+{
+	return realTimeCodeData_;
+}
+

live/src/model/DescribeLiveDomainTranscodeParamsRequest.cc

@@ -34,6 +34,15 @@ void DescribeLiveDomainTranscodeParamsRequest::setPushdomain(const std::string &
   setParameter(std::string("pushdomain"), pushdomain);
 }
 
+std::string DescribeLiveDomainTranscodeParamsRequest::getSecurityToken() const {
+  return securityToken_;
+}
+
+void DescribeLiveDomainTranscodeParamsRequest::setSecurityToken(const std::string &securityToken) {
+  securityToken_ = securityToken;
+  setParameter(std::string("SecurityToken"), securityToken);
+}
+
 std::string DescribeLiveDomainTranscodeParamsRequest::getApp() const {
   return app_;
 }

live/src/model/DescribeLiveUpVideoAudioInfoRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveUpVideoAudioInfoRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveUpVideoAudioInfoRequest;
+
+DescribeLiveUpVideoAudioInfoRequest::DescribeLiveUpVideoAudioInfoRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLiveUpVideoAudioInfo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveUpVideoAudioInfoRequest::~DescribeLiveUpVideoAudioInfoRequest() {}
+
+std::string DescribeLiveUpVideoAudioInfoRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeLiveUpVideoAudioInfoRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeLiveUpVideoAudioInfoRequest::getStream() const {
+  return stream_;
+}
+
+void DescribeLiveUpVideoAudioInfoRequest::setStream(const std::string &stream) {
+  stream_ = stream;
+  setParameter(std::string("Stream"), stream);
+}
+
+std::string DescribeLiveUpVideoAudioInfoRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeLiveUpVideoAudioInfoRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+long DescribeLiveUpVideoAudioInfoRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLiveUpVideoAudioInfoRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveUpVideoAudioInfoResult.cc

@@ -0,0 +1,195 @@
+/*
+ * 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/live/model/DescribeLiveUpVideoAudioInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveUpVideoAudioInfoResult::DescribeLiveUpVideoAudioInfoResult() :
+	ServiceResult()
+{}
+
+DescribeLiveUpVideoAudioInfoResult::DescribeLiveUpVideoAudioInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveUpVideoAudioInfoResult::~DescribeLiveUpVideoAudioInfoResult()
+{}
+
+void DescribeLiveUpVideoAudioInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allUpItemsNode = value["UpItems"]["PublishItem"];
+	for (auto valueUpItemsPublishItem : allUpItemsNode)
+	{
+		PublishItem upItemsObject;
+		if(!valueUpItemsPublishItem["PublishTime"].isNull())
+			upItemsObject.publishTime = valueUpItemsPublishItem["PublishTime"].asString();
+		if(!valueUpItemsPublishItem["AppName"].isNull())
+			upItemsObject.appName = valueUpItemsPublishItem["AppName"].asString();
+		if(!valueUpItemsPublishItem["CodecInfo"].isNull())
+			upItemsObject.codecInfo = valueUpItemsPublishItem["CodecInfo"].asString();
+		if(!valueUpItemsPublishItem["PublishIp"].isNull())
+			upItemsObject.publishIp = valueUpItemsPublishItem["PublishIp"].asString();
+		if(!valueUpItemsPublishItem["StreamName"].isNull())
+			upItemsObject.streamName = valueUpItemsPublishItem["StreamName"].asString();
+		if(!valueUpItemsPublishItem["PublishStatus"].isNull())
+			upItemsObject.publishStatus = valueUpItemsPublishItem["PublishStatus"].asString();
+		if(!valueUpItemsPublishItem["UniqueId"].isNull())
+			upItemsObject.uniqueId = valueUpItemsPublishItem["UniqueId"].asString();
+		if(!valueUpItemsPublishItem["PublishInterval"].isNull())
+			upItemsObject.publishInterval = valueUpItemsPublishItem["PublishInterval"].asString();
+		if(!valueUpItemsPublishItem["StopTime"].isNull())
+			upItemsObject.stopTime = valueUpItemsPublishItem["StopTime"].asString();
+		if(!valueUpItemsPublishItem["DomainName"].isNull())
+			upItemsObject.domainName = valueUpItemsPublishItem["DomainName"].asString();
+		auto allVideoFramesNode = valueUpItemsPublishItem["VideoFrames"]["VideoFramesItem"];
+		for (auto valueUpItemsPublishItemVideoFramesVideoFramesItem : allVideoFramesNode)
+		{
+			PublishItem::VideoFramesItem videoFramesObject;
+			if(!valueUpItemsPublishItemVideoFramesVideoFramesItem["Value"].isNull())
+				videoFramesObject.value = std::stoi(valueUpItemsPublishItemVideoFramesVideoFramesItem["Value"].asString());
+			if(!valueUpItemsPublishItemVideoFramesVideoFramesItem["Time"].isNull())
+				videoFramesObject.time = std::stol(valueUpItemsPublishItemVideoFramesVideoFramesItem["Time"].asString());
+			upItemsObject.videoFrames.push_back(videoFramesObject);
+		}
+		auto allAudioFramesNode = valueUpItemsPublishItem["AudioFrames"]["AudioFramesItem"];
+		for (auto valueUpItemsPublishItemAudioFramesAudioFramesItem : allAudioFramesNode)
+		{
+			PublishItem::AudioFramesItem audioFramesObject;
+			if(!valueUpItemsPublishItemAudioFramesAudioFramesItem["Value"].isNull())
+				audioFramesObject.value = std::stoi(valueUpItemsPublishItemAudioFramesAudioFramesItem["Value"].asString());
+			if(!valueUpItemsPublishItemAudioFramesAudioFramesItem["Time"].isNull())
+				audioFramesObject.time = std::stol(valueUpItemsPublishItemAudioFramesAudioFramesItem["Time"].asString());
+			upItemsObject.audioFrames.push_back(audioFramesObject);
+		}
+		auto allVideoStampsNode = valueUpItemsPublishItem["VideoStamps"]["VideoStampsItem"];
+		for (auto valueUpItemsPublishItemVideoStampsVideoStampsItem : allVideoStampsNode)
+		{
+			PublishItem::VideoStampsItem videoStampsObject;
+			if(!valueUpItemsPublishItemVideoStampsVideoStampsItem["Value"].isNull())
+				videoStampsObject.value = std::stoi(valueUpItemsPublishItemVideoStampsVideoStampsItem["Value"].asString());
+			if(!valueUpItemsPublishItemVideoStampsVideoStampsItem["Time"].isNull())
+				videoStampsObject.time = std::stol(valueUpItemsPublishItemVideoStampsVideoStampsItem["Time"].asString());
+			upItemsObject.videoStamps.push_back(videoStampsObject);
+		}
+		auto allAudioStampsNode = valueUpItemsPublishItem["AudioStamps"]["AudioStampsItem"];
+		for (auto valueUpItemsPublishItemAudioStampsAudioStampsItem : allAudioStampsNode)
+		{
+			PublishItem::AudioStampsItem audioStampsObject;
+			if(!valueUpItemsPublishItemAudioStampsAudioStampsItem["Value"].isNull())
+				audioStampsObject.value = std::stoi(valueUpItemsPublishItemAudioStampsAudioStampsItem["Value"].asString());
+			if(!valueUpItemsPublishItemAudioStampsAudioStampsItem["Time"].isNull())
+				audioStampsObject.time = std::stol(valueUpItemsPublishItemAudioStampsAudioStampsItem["Time"].asString());
+			upItemsObject.audioStamps.push_back(audioStampsObject);
+		}
+		auto allVideoAndAudioStampNode = valueUpItemsPublishItem["VideoAndAudioStamp"]["V_AStamp"];
+		for (auto valueUpItemsPublishItemVideoAndAudioStampV_AStamp : allVideoAndAudioStampNode)
+		{
+			PublishItem::V_AStamp videoAndAudioStampObject;
+			if(!valueUpItemsPublishItemVideoAndAudioStampV_AStamp["Value"].isNull())
+				videoAndAudioStampObject.value = std::stoi(valueUpItemsPublishItemVideoAndAudioStampV_AStamp["Value"].asString());
+			if(!valueUpItemsPublishItemVideoAndAudioStampV_AStamp["Time"].isNull())
+				videoAndAudioStampObject.time = std::stol(valueUpItemsPublishItemVideoAndAudioStampV_AStamp["Time"].asString());
+			upItemsObject.videoAndAudioStamp.push_back(videoAndAudioStampObject);
+		}
+		auto allAvcHeadersNode = valueUpItemsPublishItem["AvcHeaders"]["AvcHeadersItem"];
+		for (auto valueUpItemsPublishItemAvcHeadersAvcHeadersItem : allAvcHeadersNode)
+		{
+			PublishItem::AvcHeadersItem avcHeadersObject;
+			if(!valueUpItemsPublishItemAvcHeadersAvcHeadersItem["Value"].isNull())
+				avcHeadersObject.value = std::stoi(valueUpItemsPublishItemAvcHeadersAvcHeadersItem["Value"].asString());
+			if(!valueUpItemsPublishItemAvcHeadersAvcHeadersItem["Time"].isNull())
+				avcHeadersObject.time = std::stol(valueUpItemsPublishItemAvcHeadersAvcHeadersItem["Time"].asString());
+			upItemsObject.avcHeaders.push_back(avcHeadersObject);
+		}
+		auto allAacHeadersNode = valueUpItemsPublishItem["AacHeaders"]["AacHeadersItem"];
+		for (auto valueUpItemsPublishItemAacHeadersAacHeadersItem : allAacHeadersNode)
+		{
+			PublishItem::AacHeadersItem aacHeadersObject;
+			if(!valueUpItemsPublishItemAacHeadersAacHeadersItem["Value"].isNull())
+				aacHeadersObject.value = std::stoi(valueUpItemsPublishItemAacHeadersAacHeadersItem["Value"].asString());
+			if(!valueUpItemsPublishItemAacHeadersAacHeadersItem["Time"].isNull())
+				aacHeadersObject.time = std::stol(valueUpItemsPublishItemAacHeadersAacHeadersItem["Time"].asString());
+			upItemsObject.aacHeaders.push_back(aacHeadersObject);
+		}
+		auto allVideoBitRateNode = valueUpItemsPublishItem["VideoBitRate"]["VideoBitRateItem"];
+		for (auto valueUpItemsPublishItemVideoBitRateVideoBitRateItem : allVideoBitRateNode)
+		{
+			PublishItem::VideoBitRateItem videoBitRateObject;
+			if(!valueUpItemsPublishItemVideoBitRateVideoBitRateItem["Value"].isNull())
+				videoBitRateObject.value = std::stoi(valueUpItemsPublishItemVideoBitRateVideoBitRateItem["Value"].asString());
+			if(!valueUpItemsPublishItemVideoBitRateVideoBitRateItem["Time"].isNull())
+				videoBitRateObject.time = std::stol(valueUpItemsPublishItemVideoBitRateVideoBitRateItem["Time"].asString());
+			upItemsObject.videoBitRate.push_back(videoBitRateObject);
+		}
+		auto allAudioBitRateNode = valueUpItemsPublishItem["AudioBitRate"]["AudioBitRateItem"];
+		for (auto valueUpItemsPublishItemAudioBitRateAudioBitRateItem : allAudioBitRateNode)
+		{
+			PublishItem::AudioBitRateItem audioBitRateObject;
+			if(!valueUpItemsPublishItemAudioBitRateAudioBitRateItem["Value"].isNull())
+				audioBitRateObject.value = std::stoi(valueUpItemsPublishItemAudioBitRateAudioBitRateItem["Value"].asString());
+			if(!valueUpItemsPublishItemAudioBitRateAudioBitRateItem["Time"].isNull())
+				audioBitRateObject.time = std::stol(valueUpItemsPublishItemAudioBitRateAudioBitRateItem["Time"].asString());
+			upItemsObject.audioBitRate.push_back(audioBitRateObject);
+		}
+		auto allVideoIntervalNode = valueUpItemsPublishItem["VideoInterval"]["VideoIntervalItem"];
+		for (auto valueUpItemsPublishItemVideoIntervalVideoIntervalItem : allVideoIntervalNode)
+		{
+			PublishItem::VideoIntervalItem videoIntervalObject;
+			if(!valueUpItemsPublishItemVideoIntervalVideoIntervalItem["Value"].isNull())
+				videoIntervalObject.value = std::stoi(valueUpItemsPublishItemVideoIntervalVideoIntervalItem["Value"].asString());
+			if(!valueUpItemsPublishItemVideoIntervalVideoIntervalItem["Time"].isNull())
+				videoIntervalObject.time = std::stol(valueUpItemsPublishItemVideoIntervalVideoIntervalItem["Time"].asString());
+			upItemsObject.videoInterval.push_back(videoIntervalObject);
+		}
+		auto allAudioIntervalNode = valueUpItemsPublishItem["AudioInterval"]["AudioIntervalItem"];
+		for (auto valueUpItemsPublishItemAudioIntervalAudioIntervalItem : allAudioIntervalNode)
+		{
+			PublishItem::AudioIntervalItem audioIntervalObject;
+			if(!valueUpItemsPublishItemAudioIntervalAudioIntervalItem["Value"].isNull())
+				audioIntervalObject.value = std::stoi(valueUpItemsPublishItemAudioIntervalAudioIntervalItem["Value"].asString());
+			if(!valueUpItemsPublishItemAudioIntervalAudioIntervalItem["Time"].isNull())
+				audioIntervalObject.time = std::stol(valueUpItemsPublishItemAudioIntervalAudioIntervalItem["Time"].asString());
+			upItemsObject.audioInterval.push_back(audioIntervalObject);
+		}
+		auto allErrorFlagsNode = valueUpItemsPublishItem["ErrorFlags"]["ErrorFlagsItem"];
+		for (auto valueUpItemsPublishItemErrorFlagsErrorFlagsItem : allErrorFlagsNode)
+		{
+			PublishItem::ErrorFlagsItem errorFlagsObject;
+			if(!valueUpItemsPublishItemErrorFlagsErrorFlagsItem["Value"].isNull())
+				errorFlagsObject.value = std::stoi(valueUpItemsPublishItemErrorFlagsErrorFlagsItem["Value"].asString());
+			if(!valueUpItemsPublishItemErrorFlagsErrorFlagsItem["Time"].isNull())
+				errorFlagsObject.time = std::stol(valueUpItemsPublishItemErrorFlagsErrorFlagsItem["Time"].asString());
+			upItemsObject.errorFlags.push_back(errorFlagsObject);
+		}
+		upItems_.push_back(upItemsObject);
+	}
+
+}
+
+std::vector<DescribeLiveUpVideoAudioInfoResult::PublishItem> DescribeLiveUpVideoAudioInfoResult::getUpItems()const
+{
+	return upItems_;
+}
+

live/src/model/ListLiveMessageGroupMessagesRequest.cc

@@ -43,6 +43,24 @@ void ListLiveMessageGroupMessagesRequest::setNextPageToken(long nextPageToken) {
   setParameter(std::string("NextPageToken"), std::to_string(nextPageToken));
 }
 
+int ListLiveMessageGroupMessagesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListLiveMessageGroupMessagesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+long ListLiveMessageGroupMessagesRequest::getMsgType() const {
+  return msgType_;
+}
+
+void ListLiveMessageGroupMessagesRequest::setMsgType(long msgType) {
+  msgType_ = msgType;
+  setParameter(std::string("MsgType"), std::to_string(msgType));
+}
+
 std::string ListLiveMessageGroupMessagesRequest::getGroupId() const {
   return groupId_;
 }
@@ -88,21 +106,3 @@ void ListLiveMessageGroupMessagesRequest::setAppId(const std::string &appId) {
   setParameter(std::string("AppId"), appId);
 }
 
-int ListLiveMessageGroupMessagesRequest::getPageSize() const {
-  return pageSize_;
-}
-
-void ListLiveMessageGroupMessagesRequest::setPageSize(int pageSize) {
-  pageSize_ = pageSize;
-  setParameter(std::string("PageSize"), std::to_string(pageSize));
-}
-
-long ListLiveMessageGroupMessagesRequest::getMsgType() const {
-  return msgType_;
-}
-
-void ListLiveMessageGroupMessagesRequest::setMsgType(long msgType) {
-  msgType_ = msgType;
-  setParameter(std::string("MsgType"), std::to_string(msgType));
-}
-

live/src/model/ListMuteGroupUserRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/live/model/ListMuteGroupUserRequest.h>
+
+using AlibabaCloud::Live::Model::ListMuteGroupUserRequest;
+
+ListMuteGroupUserRequest::ListMuteGroupUserRequest()
+    : RpcServiceRequest("live", "2016-11-01", "ListMuteGroupUser") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListMuteGroupUserRequest::~ListMuteGroupUserRequest() {}
+
+int ListMuteGroupUserRequest::getPageNum() const {
+  return pageNum_;
+}
+
+void ListMuteGroupUserRequest::setPageNum(int pageNum) {
+  pageNum_ = pageNum;
+  setBodyParameter(std::string("PageNum"), std::to_string(pageNum));
+}
+
+int ListMuteGroupUserRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListMuteGroupUserRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListMuteGroupUserRequest::getOperatorUserId() const {
+  return operatorUserId_;
+}
+
+void ListMuteGroupUserRequest::setOperatorUserId(const std::string &operatorUserId) {
+  operatorUserId_ = operatorUserId;
+  setBodyParameter(std::string("OperatorUserId"), operatorUserId);
+}
+
+std::string ListMuteGroupUserRequest::getGroupId() const {
+  return groupId_;
+}
+
+void ListMuteGroupUserRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setBodyParameter(std::string("GroupId"), groupId);
+}
+
+std::string ListMuteGroupUserRequest::getAppId() const {
+  return appId_;
+}
+
+void ListMuteGroupUserRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setBodyParameter(std::string("AppId"), appId);
+}
+

live/src/model/ListMuteGroupUserResult.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/live/model/ListMuteGroupUserResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+ListMuteGroupUserResult::ListMuteGroupUserResult() :
+	ServiceResult()
+{}
+
+ListMuteGroupUserResult::ListMuteGroupUserResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListMuteGroupUserResult::~ListMuteGroupUserResult()
+{}
+
+void ListMuteGroupUserResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
+	if(!resultNode["HasMore"].isNull())
+		result_.hasMore = resultNode["HasMore"].asString() == "true";
+	auto allUserListNode = resultNode["UserList"]["userListItem"];
+	for (auto resultNodeUserListuserListItem : allUserListNode)
+	{
+		Result::UserListItem userListItemObject;
+		if(!resultNodeUserListuserListItem["UserId"].isNull())
+			userListItemObject.userId = resultNodeUserListuserListItem["UserId"].asString();
+		result_.userList.push_back(userListItemObject);
+	}
+
+}
+
+ListMuteGroupUserResult::Result ListMuteGroupUserResult::getResult()const
+{
+	return result_;
+}
+

live/src/model/StartLiveMPUTaskRequest.cc

@@ -42,11 +42,11 @@ StartLiveMPUTaskRequest::SeiParams StartLiveMPUTaskRequest::getSeiParams() const
 
 void StartLiveMPUTaskRequest::setSeiParams(const StartLiveMPUTaskRequest::SeiParams &seiParams) {
   seiParams_ = seiParams;
+  setParameter(std::string("SeiParams") + ".PayloadType", seiParams.payloadType);
   setParameter(std::string("SeiParams") + ".LayoutVolume.FollowIdr", seiParams.layoutVolume.followIdr);
-  setParameter(std::string("SeiParams") + ".LayoutVolume.PayloadType", seiParams.layoutVolume.payloadType);
   setParameter(std::string("SeiParams") + ".LayoutVolume.Interval", seiParams.layoutVolume.interval);
   setParameter(std::string("SeiParams") + ".PassThrough.FollowIdr", seiParams.passThrough.followIdr);
-  setParameter(std::string("SeiParams") + ".PassThrough.PayloadType", seiParams.passThrough.payloadType);
+  setParameter(std::string("SeiParams") + ".PassThrough.PayloadContentKey", seiParams.passThrough.payloadContentKey);
   setParameter(std::string("SeiParams") + ".PassThrough.PayloadContent", seiParams.passThrough.payloadContent);
   setParameter(std::string("SeiParams") + ".PassThrough.Interval", seiParams.passThrough.interval);
 }

live/src/model/UpdateLiveMPUTaskRequest.cc

@@ -43,10 +43,9 @@ UpdateLiveMPUTaskRequest::SeiParams UpdateLiveMPUTaskRequest::getSeiParams() con
 void UpdateLiveMPUTaskRequest::setSeiParams(const UpdateLiveMPUTaskRequest::SeiParams &seiParams) {
   seiParams_ = seiParams;
   setParameter(std::string("SeiParams") + ".LayoutVolume.FollowIdr", seiParams.layoutVolume.followIdr);
-  setParameter(std::string("SeiParams") + ".LayoutVolume.PayloadType", seiParams.layoutVolume.payloadType);
   setParameter(std::string("SeiParams") + ".LayoutVolume.Interval", seiParams.layoutVolume.interval);
   setParameter(std::string("SeiParams") + ".PassThrough.FollowIdr", seiParams.passThrough.followIdr);
-  setParameter(std::string("SeiParams") + ".PassThrough.PayloadType", seiParams.passThrough.payloadType);
+  setParameter(std::string("SeiParams") + ".PassThrough.PayloadContentKey", seiParams.passThrough.payloadContentKey);
   setParameter(std::string("SeiParams") + ".PassThrough.PayloadContent", seiParams.passThrough.payloadContent);
   setParameter(std::string("SeiParams") + ".PassThrough.Interval", seiParams.passThrough.interval);
 }