Update to support new apis.

VERSION

@@ -1 +1 @@
-1.36.1807
+1.36.1808

live/CMakeLists.txt

@@ -137,6 +137,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/CreateMessageGroupResult.h
 	include/alibabacloud/live/model/CreateMixStreamRequest.h
 	include/alibabacloud/live/model/CreateMixStreamResult.h
+	include/alibabacloud/live/model/CreateRoomRealTimeStreamAddressRequest.h
+	include/alibabacloud/live/model/CreateRoomRealTimeStreamAddressResult.h
 	include/alibabacloud/live/model/DeleteCasterRequest.h
 	include/alibabacloud/live/model/DeleteCasterResult.h
 	include/alibabacloud/live/model/DeleteCasterComponentRequest.h
@@ -315,6 +317,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainLimitResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainLogRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainLogResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainLogExTtlRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainLogExTtlResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainMappingRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainMappingResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainMonitoringUsageDataRequest.h
@@ -359,6 +363,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveEdgeTransferResult.h
 	include/alibabacloud/live/model/DescribeLiveGrtnDurationRequest.h
 	include/alibabacloud/live/model/DescribeLiveGrtnDurationResult.h
+	include/alibabacloud/live/model/DescribeLiveGrtnTrafficUsageRequest.h
+	include/alibabacloud/live/model/DescribeLiveGrtnTrafficUsageResult.h
 	include/alibabacloud/live/model/DescribeLiveHttpsDomainListRequest.h
 	include/alibabacloud/live/model/DescribeLiveHttpsDomainListResult.h
 	include/alibabacloud/live/model/DescribeLiveIpInfoRequest.h
@@ -433,6 +439,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveStreamStateResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoRequest.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoResult.h
+	include/alibabacloud/live/model/DescribeLiveStreamTranscodeMetricDataRequest.h
+	include/alibabacloud/live/model/DescribeLiveStreamTranscodeMetricDataResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeStreamNumRequest.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeStreamNumResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesRequest.h
@@ -888,6 +896,8 @@ set(live_src
 	src/model/CreateMessageGroupResult.cc
 	src/model/CreateMixStreamRequest.cc
 	src/model/CreateMixStreamResult.cc
+	src/model/CreateRoomRealTimeStreamAddressRequest.cc
+	src/model/CreateRoomRealTimeStreamAddressResult.cc
 	src/model/DeleteCasterRequest.cc
 	src/model/DeleteCasterResult.cc
 	src/model/DeleteCasterComponentRequest.cc
@@ -1066,6 +1076,8 @@ set(live_src
 	src/model/DescribeLiveDomainLimitResult.cc
 	src/model/DescribeLiveDomainLogRequest.cc
 	src/model/DescribeLiveDomainLogResult.cc
+	src/model/DescribeLiveDomainLogExTtlRequest.cc
+	src/model/DescribeLiveDomainLogExTtlResult.cc
 	src/model/DescribeLiveDomainMappingRequest.cc
 	src/model/DescribeLiveDomainMappingResult.cc
 	src/model/DescribeLiveDomainMonitoringUsageDataRequest.cc
@@ -1110,6 +1122,8 @@ set(live_src
 	src/model/DescribeLiveEdgeTransferResult.cc
 	src/model/DescribeLiveGrtnDurationRequest.cc
 	src/model/DescribeLiveGrtnDurationResult.cc
+	src/model/DescribeLiveGrtnTrafficUsageRequest.cc
+	src/model/DescribeLiveGrtnTrafficUsageResult.cc
 	src/model/DescribeLiveHttpsDomainListRequest.cc
 	src/model/DescribeLiveHttpsDomainListResult.cc
 	src/model/DescribeLiveIpInfoRequest.cc
@@ -1184,6 +1198,8 @@ set(live_src
 	src/model/DescribeLiveStreamStateResult.cc
 	src/model/DescribeLiveStreamTranscodeInfoRequest.cc
 	src/model/DescribeLiveStreamTranscodeInfoResult.cc
+	src/model/DescribeLiveStreamTranscodeMetricDataRequest.cc
+	src/model/DescribeLiveStreamTranscodeMetricDataResult.cc
 	src/model/DescribeLiveStreamTranscodeStreamNumRequest.cc
 	src/model/DescribeLiveStreamTranscodeStreamNumResult.cc
 	src/model/DescribeLiveStreamWatermarkRulesRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -138,6 +138,8 @@
 #include "model/CreateMessageGroupResult.h"
 #include "model/CreateMixStreamRequest.h"
 #include "model/CreateMixStreamResult.h"
+#include "model/CreateRoomRealTimeStreamAddressRequest.h"
+#include "model/CreateRoomRealTimeStreamAddressResult.h"
 #include "model/DeleteCasterRequest.h"
 #include "model/DeleteCasterResult.h"
 #include "model/DeleteCasterComponentRequest.h"
@@ -316,6 +318,8 @@
 #include "model/DescribeLiveDomainLimitResult.h"
 #include "model/DescribeLiveDomainLogRequest.h"
 #include "model/DescribeLiveDomainLogResult.h"
+#include "model/DescribeLiveDomainLogExTtlRequest.h"
+#include "model/DescribeLiveDomainLogExTtlResult.h"
 #include "model/DescribeLiveDomainMappingRequest.h"
 #include "model/DescribeLiveDomainMappingResult.h"
 #include "model/DescribeLiveDomainMonitoringUsageDataRequest.h"
@@ -360,6 +364,8 @@
 #include "model/DescribeLiveEdgeTransferResult.h"
 #include "model/DescribeLiveGrtnDurationRequest.h"
 #include "model/DescribeLiveGrtnDurationResult.h"
+#include "model/DescribeLiveGrtnTrafficUsageRequest.h"
+#include "model/DescribeLiveGrtnTrafficUsageResult.h"
 #include "model/DescribeLiveHttpsDomainListRequest.h"
 #include "model/DescribeLiveHttpsDomainListResult.h"
 #include "model/DescribeLiveIpInfoRequest.h"
@@ -434,6 +440,8 @@
 #include "model/DescribeLiveStreamStateResult.h"
 #include "model/DescribeLiveStreamTranscodeInfoRequest.h"
 #include "model/DescribeLiveStreamTranscodeInfoResult.h"
+#include "model/DescribeLiveStreamTranscodeMetricDataRequest.h"
+#include "model/DescribeLiveStreamTranscodeMetricDataResult.h"
 #include "model/DescribeLiveStreamTranscodeStreamNumRequest.h"
 #include "model/DescribeLiveStreamTranscodeStreamNumResult.h"
 #include "model/DescribeLiveStreamWatermarkRulesRequest.h"
@@ -953,6 +961,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateMixStreamResult> CreateMixStreamOutcome;
 			typedef std::future<CreateMixStreamOutcome> CreateMixStreamOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::CreateMixStreamRequest&, const CreateMixStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMixStreamAsyncHandler;
+			typedef Outcome<Error, Model::CreateRoomRealTimeStreamAddressResult> CreateRoomRealTimeStreamAddressOutcome;
+			typedef std::future<CreateRoomRealTimeStreamAddressOutcome> CreateRoomRealTimeStreamAddressOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::CreateRoomRealTimeStreamAddressRequest&, const CreateRoomRealTimeStreamAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRoomRealTimeStreamAddressAsyncHandler;
 			typedef Outcome<Error, Model::DeleteCasterResult> DeleteCasterOutcome;
 			typedef std::future<DeleteCasterOutcome> DeleteCasterOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteCasterRequest&, const DeleteCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterAsyncHandler;
@@ -1220,6 +1231,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainLogResult> DescribeLiveDomainLogOutcome;
 			typedef std::future<DescribeLiveDomainLogOutcome> DescribeLiveDomainLogOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainLogRequest&, const DescribeLiveDomainLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainLogAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainLogExTtlResult> DescribeLiveDomainLogExTtlOutcome;
+			typedef std::future<DescribeLiveDomainLogExTtlOutcome> DescribeLiveDomainLogExTtlOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainLogExTtlRequest&, const DescribeLiveDomainLogExTtlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainLogExTtlAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainMappingResult> DescribeLiveDomainMappingOutcome;
 			typedef std::future<DescribeLiveDomainMappingOutcome> DescribeLiveDomainMappingOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainMappingRequest&, const DescribeLiveDomainMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainMappingAsyncHandler;
@@ -1286,6 +1300,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveGrtnDurationResult> DescribeLiveGrtnDurationOutcome;
 			typedef std::future<DescribeLiveGrtnDurationOutcome> DescribeLiveGrtnDurationOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveGrtnDurationRequest&, const DescribeLiveGrtnDurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveGrtnDurationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveGrtnTrafficUsageResult> DescribeLiveGrtnTrafficUsageOutcome;
+			typedef std::future<DescribeLiveGrtnTrafficUsageOutcome> DescribeLiveGrtnTrafficUsageOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveGrtnTrafficUsageRequest&, const DescribeLiveGrtnTrafficUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveGrtnTrafficUsageAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveHttpsDomainListResult> DescribeLiveHttpsDomainListOutcome;
 			typedef std::future<DescribeLiveHttpsDomainListOutcome> DescribeLiveHttpsDomainListOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveHttpsDomainListRequest&, const DescribeLiveHttpsDomainListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveHttpsDomainListAsyncHandler;
@@ -1397,6 +1414,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveStreamTranscodeInfoResult> DescribeLiveStreamTranscodeInfoOutcome;
 			typedef std::future<DescribeLiveStreamTranscodeInfoOutcome> DescribeLiveStreamTranscodeInfoOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamTranscodeInfoRequest&, const DescribeLiveStreamTranscodeInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamTranscodeInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveStreamTranscodeMetricDataResult> DescribeLiveStreamTranscodeMetricDataOutcome;
+			typedef std::future<DescribeLiveStreamTranscodeMetricDataOutcome> DescribeLiveStreamTranscodeMetricDataOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamTranscodeMetricDataRequest&, const DescribeLiveStreamTranscodeMetricDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamTranscodeMetricDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveStreamTranscodeStreamNumResult> DescribeLiveStreamTranscodeStreamNumOutcome;
 			typedef std::future<DescribeLiveStreamTranscodeStreamNumOutcome> DescribeLiveStreamTranscodeStreamNumOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamTranscodeStreamNumRequest&, const DescribeLiveStreamTranscodeStreamNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamTranscodeStreamNumAsyncHandler;
@@ -2080,6 +2100,9 @@ namespace AlibabaCloud
 			CreateMixStreamOutcome createMixStream(const Model::CreateMixStreamRequest &request)const;
 			void createMixStreamAsync(const Model::CreateMixStreamRequest& request, const CreateMixStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateMixStreamOutcomeCallable createMixStreamCallable(const Model::CreateMixStreamRequest& request) const;
+			CreateRoomRealTimeStreamAddressOutcome createRoomRealTimeStreamAddress(const Model::CreateRoomRealTimeStreamAddressRequest &request)const;
+			void createRoomRealTimeStreamAddressAsync(const Model::CreateRoomRealTimeStreamAddressRequest& request, const CreateRoomRealTimeStreamAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateRoomRealTimeStreamAddressOutcomeCallable createRoomRealTimeStreamAddressCallable(const Model::CreateRoomRealTimeStreamAddressRequest& request) const;
 			DeleteCasterOutcome deleteCaster(const Model::DeleteCasterRequest &request)const;
 			void deleteCasterAsync(const Model::DeleteCasterRequest& request, const DeleteCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteCasterOutcomeCallable deleteCasterCallable(const Model::DeleteCasterRequest& request) const;
@@ -2347,6 +2370,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainLogOutcome describeLiveDomainLog(const Model::DescribeLiveDomainLogRequest &request)const;
 			void describeLiveDomainLogAsync(const Model::DescribeLiveDomainLogRequest& request, const DescribeLiveDomainLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainLogOutcomeCallable describeLiveDomainLogCallable(const Model::DescribeLiveDomainLogRequest& request) const;
+			DescribeLiveDomainLogExTtlOutcome describeLiveDomainLogExTtl(const Model::DescribeLiveDomainLogExTtlRequest &request)const;
+			void describeLiveDomainLogExTtlAsync(const Model::DescribeLiveDomainLogExTtlRequest& request, const DescribeLiveDomainLogExTtlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainLogExTtlOutcomeCallable describeLiveDomainLogExTtlCallable(const Model::DescribeLiveDomainLogExTtlRequest& request) const;
 			DescribeLiveDomainMappingOutcome describeLiveDomainMapping(const Model::DescribeLiveDomainMappingRequest &request)const;
 			void describeLiveDomainMappingAsync(const Model::DescribeLiveDomainMappingRequest& request, const DescribeLiveDomainMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainMappingOutcomeCallable describeLiveDomainMappingCallable(const Model::DescribeLiveDomainMappingRequest& request) const;
@@ -2413,6 +2439,9 @@ namespace AlibabaCloud
 			DescribeLiveGrtnDurationOutcome describeLiveGrtnDuration(const Model::DescribeLiveGrtnDurationRequest &request)const;
 			void describeLiveGrtnDurationAsync(const Model::DescribeLiveGrtnDurationRequest& request, const DescribeLiveGrtnDurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveGrtnDurationOutcomeCallable describeLiveGrtnDurationCallable(const Model::DescribeLiveGrtnDurationRequest& request) const;
+			DescribeLiveGrtnTrafficUsageOutcome describeLiveGrtnTrafficUsage(const Model::DescribeLiveGrtnTrafficUsageRequest &request)const;
+			void describeLiveGrtnTrafficUsageAsync(const Model::DescribeLiveGrtnTrafficUsageRequest& request, const DescribeLiveGrtnTrafficUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveGrtnTrafficUsageOutcomeCallable describeLiveGrtnTrafficUsageCallable(const Model::DescribeLiveGrtnTrafficUsageRequest& request) const;
 			DescribeLiveHttpsDomainListOutcome describeLiveHttpsDomainList(const Model::DescribeLiveHttpsDomainListRequest &request)const;
 			void describeLiveHttpsDomainListAsync(const Model::DescribeLiveHttpsDomainListRequest& request, const DescribeLiveHttpsDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveHttpsDomainListOutcomeCallable describeLiveHttpsDomainListCallable(const Model::DescribeLiveHttpsDomainListRequest& request) const;
@@ -2524,6 +2553,9 @@ namespace AlibabaCloud
 			DescribeLiveStreamTranscodeInfoOutcome describeLiveStreamTranscodeInfo(const Model::DescribeLiveStreamTranscodeInfoRequest &request)const;
 			void describeLiveStreamTranscodeInfoAsync(const Model::DescribeLiveStreamTranscodeInfoRequest& request, const DescribeLiveStreamTranscodeInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveStreamTranscodeInfoOutcomeCallable describeLiveStreamTranscodeInfoCallable(const Model::DescribeLiveStreamTranscodeInfoRequest& request) const;
+			DescribeLiveStreamTranscodeMetricDataOutcome describeLiveStreamTranscodeMetricData(const Model::DescribeLiveStreamTranscodeMetricDataRequest &request)const;
+			void describeLiveStreamTranscodeMetricDataAsync(const Model::DescribeLiveStreamTranscodeMetricDataRequest& request, const DescribeLiveStreamTranscodeMetricDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveStreamTranscodeMetricDataOutcomeCallable describeLiveStreamTranscodeMetricDataCallable(const Model::DescribeLiveStreamTranscodeMetricDataRequest& request) const;
 			DescribeLiveStreamTranscodeStreamNumOutcome describeLiveStreamTranscodeStreamNum(const Model::DescribeLiveStreamTranscodeStreamNumRequest &request)const;
 			void describeLiveStreamTranscodeStreamNumAsync(const Model::DescribeLiveStreamTranscodeStreamNumRequest& request, const DescribeLiveStreamTranscodeStreamNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveStreamTranscodeStreamNumOutcomeCallable describeLiveStreamTranscodeStreamNumCallable(const Model::DescribeLiveStreamTranscodeStreamNumRequest& request) const;

live/include/alibabacloud/live/model/CreateEventSubRequest.h

@@ -30,12 +30,6 @@ class ALIBABACLOUD_LIVE_EXPORT CreateEventSubRequest : public RpcServiceRequest
 public:
 	CreateEventSubRequest();
 	~CreateEventSubRequest();
-	int getRole() const;
-	void setRole(int role);
-	std::string getClientToken() const;
-	void setClientToken(const std::string &clientToken);
-	bool getNeedCallbackAuthorization() const;
-	void setNeedCallbackAuthorization(bool needCallbackAuthorization);
 	std::vector<std::string> getUsers() const;
 	void setUsers(const std::vector<std::string> &users);
 	std::string getAppId() const;
@@ -48,9 +42,6 @@ public:
 	void setEvents(const std::vector<std::string> &events);
 
 private:
-	int role_;
-	std::string clientToken_;
-	bool needCallbackAuthorization_;
 	std::vector<std::string> users_;
 	std::string appId_;
 	std::string callbackUrl_;

live/include/alibabacloud/live/model/CreateRoomRealTimeStreamAddressRequest.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_CREATEROOMREALTIMESTREAMADDRESSREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_CREATEROOMREALTIMESTREAMADDRESSREQUEST_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 CreateRoomRealTimeStreamAddressRequest : public RpcServiceRequest {
+public:
+	CreateRoomRealTimeStreamAddressRequest();
+	~CreateRoomRealTimeStreamAddressRequest();
+	int getExpireTime() const;
+	void setExpireTime(int expireTime);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getDisplayName() const;
+	void setDisplayName(const std::string &displayName);
+	std::string getChannelId() const;
+	void setChannelId(const std::string &channelId);
+
+private:
+	int expireTime_;
+	std::string userId_;
+	std::string appId_;
+	std::string displayName_;
+	std::string channelId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_CREATEROOMREALTIMESTREAMADDRESSREQUEST_H_

live/include/alibabacloud/live/model/CreateRoomRealTimeStreamAddressResult.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_CREATEROOMREALTIMESTREAMADDRESSRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_CREATEROOMREALTIMESTREAMADDRESSRESULT_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 CreateRoomRealTimeStreamAddressResult : public ServiceResult
+			{
+			public:
+
+
+				CreateRoomRealTimeStreamAddressResult();
+				explicit CreateRoomRealTimeStreamAddressResult(const std::string &payload);
+				~CreateRoomRealTimeStreamAddressResult();
+				std::string getRtmpAddress()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string rtmpAddress_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_CREATEROOMREALTIMESTREAMADDRESSRESULT_H_

live/include/alibabacloud/live/model/DescribeCasterConfigResult.h

@@ -65,6 +65,7 @@ namespace AlibabaCloud
 				int getChannelEnable()const;
 				std::string getDomainName()const;
 				std::string getUrgentImageUrl()const;
+				std::string getAutoSwitchUrgentConfig()const;
 				std::string getUrgentMaterialId()const;
 				std::string getSideOutputUrlList()const;
 				TranscodeConfig getTranscodeConfig()const;
@@ -75,6 +76,7 @@ namespace AlibabaCloud
 				std::string getSideOutputUrl()const;
 				std::string getCasterName()const;
 				int getProgramEffect()const;
+				std::string getAutoSwitchUrgentOn()const;
 				std::vector<SyncGroup> getSyncGroupsConfig()const;
 				std::string getCasterId()const;
 				RecordConfig getRecordConfig()const;
@@ -86,6 +88,7 @@ namespace AlibabaCloud
 				int channelEnable_;
 				std::string domainName_;
 				std::string urgentImageUrl_;
+				std::string autoSwitchUrgentConfig_;
 				std::string urgentMaterialId_;
 				std::string sideOutputUrlList_;
 				TranscodeConfig transcodeConfig_;
@@ -96,6 +99,7 @@ namespace AlibabaCloud
 				std::string sideOutputUrl_;
 				std::string casterName_;
 				int programEffect_;
+				std::string autoSwitchUrgentOn_;
 				std::vector<SyncGroup> syncGroupsConfig_;
 				std::string casterId_;
 				RecordConfig recordConfig_;

live/include/alibabacloud/live/model/DescribeLiveDomainLogExTtlRequest.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_LIVE_MODEL_DESCRIBELIVEDOMAINLOGEXTTLREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLOGEXTTLREQUEST_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 DescribeLiveDomainLogExTtlRequest : public RpcServiceRequest {
+public:
+	DescribeLiveDomainLogExTtlRequest();
+	~DescribeLiveDomainLogExTtlRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	std::string getLogType() const;
+	void setLogType(const std::string &logType);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	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_;
+	long pageNumber_;
+	std::string logType_;
+	long pageSize_;
+	std::string domainName_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLOGEXTTLREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainLogExTtlResult.h

@@ -0,0 +1,73 @@
+/*
+ * 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_DESCRIBELIVEDOMAINLOGEXTTLRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLOGEXTTLRESULT_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 DescribeLiveDomainLogExTtlResult : public ServiceResult
+			{
+			public:
+				struct DomainLogDetail
+				{
+					struct PageInfos
+					{
+						long pageSize;
+						long total;
+						long pageIndex;
+					};
+					struct LogInfoDetail
+					{
+						long logSize;
+						std::string endTime;
+						std::string startTime;
+						std::string logName;
+						std::string logPath;
+					};
+					std::vector<DomainLogDetail::LogInfoDetail> logInfos;
+					PageInfos pageInfos;
+					long logCount;
+				};
+
+
+				DescribeLiveDomainLogExTtlResult();
+				explicit DescribeLiveDomainLogExTtlResult(const std::string &payload);
+				~DescribeLiveDomainLogExTtlResult();
+				std::string getDomainName()const;
+				std::vector<DomainLogDetail> getDomainLogDetails()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string domainName_;
+				std::vector<DomainLogDetail> domainLogDetails_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLOGEXTTLRESULT_H_

live/include/alibabacloud/live/model/DescribeLiveGrtnTrafficUsageRequest.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_LIVE_MODEL_DESCRIBELIVEGRTNTRAFFICUSAGEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEGRTNTRAFFICUSAGEREQUEST_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 DescribeLiveGrtnTrafficUsageRequest : public RpcServiceRequest {
+public:
+	DescribeLiveGrtnTrafficUsageRequest();
+	~DescribeLiveGrtnTrafficUsageRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getArea() const;
+	void setArea(const std::string &area);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getField() const;
+	void setField(const std::string &field);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getInterval() const;
+	void setInterval(const std::string &interval);
+
+private:
+	std::string startTime_;
+	std::string area_;
+	std::string endTime_;
+	long ownerId_;
+	std::string field_;
+	std::string appId_;
+	std::string interval_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEGRTNTRAFFICUSAGEREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveGrtnTrafficUsageResult.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_LIVE_MODEL_DESCRIBELIVEGRTNTRAFFICUSAGERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEGRTNTRAFFICUSAGERESULT_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 DescribeLiveGrtnTrafficUsageResult : public ServiceResult
+			{
+			public:
+				struct UsageData
+				{
+					double value;
+					std::string timeStamp;
+				};
+
+
+				DescribeLiveGrtnTrafficUsageResult();
+				explicit DescribeLiveGrtnTrafficUsageResult(const std::string &payload);
+				~DescribeLiveGrtnTrafficUsageResult();
+				std::vector<UsageData> getUsageDataPerInterval()const;
+				std::string getArea()const;
+				std::string getFiled()const;
+				std::string getEndTime()const;
+				std::string getAppId()const;
+				std::string getStartTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<UsageData> usageDataPerInterval_;
+				std::string area_;
+				std::string filed_;
+				std::string endTime_;
+				std::string appId_;
+				std::string startTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEGRTNTRAFFICUSAGERESULT_H_

live/include/alibabacloud/live/model/DescribeLiveStreamTranscodeMetricDataRequest.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_LIVE_MODEL_DESCRIBELIVESTREAMTRANSCODEMETRICDATAREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMTRANSCODEMETRICDATAREQUEST_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 DescribeLiveStreamTranscodeMetricDataRequest : public RpcServiceRequest {
+public:
+	DescribeLiveStreamTranscodeMetricDataRequest();
+	~DescribeLiveStreamTranscodeMetricDataRequest();
+	std::string getNextPageToken() const;
+	void setNextPageToken(const std::string &nextPageToken);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	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 nextPageToken_;
+	std::string startTime_;
+	std::string appName_;
+	std::string streamName_;
+	std::string domainName_;
+	std::string endTime_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMTRANSCODEMETRICDATAREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveStreamTranscodeMetricDataResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMTRANSCODEMETRICDATARESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMTRANSCODEMETRICDATARESULT_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 DescribeLiveStreamTranscodeMetricDataResult : public ServiceResult
+			{
+			public:
+				struct StreamData
+				{
+					std::string streamName;
+					std::string fps;
+					std::string region;
+					long duration;
+					std::string timeStamp;
+					std::string transcodeType;
+					std::string appName;
+					std::string resolution;
+				};
+
+
+				DescribeLiveStreamTranscodeMetricDataResult();
+				explicit DescribeLiveStreamTranscodeMetricDataResult(const std::string &payload);
+				~DescribeLiveStreamTranscodeMetricDataResult();
+				std::string getEndTime()const;
+				int getPageSize()const;
+				std::string getDomainName()const;
+				std::string getNextPageToken()const;
+				std::string getStartTime()const;
+				std::vector<StreamData> getStreamDetailData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				int pageSize_;
+				std::string domainName_;
+				std::string nextPageToken_;
+				std::string startTime_;
+				std::vector<StreamData> streamDetailData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMTRANSCODEMETRICDATARESULT_H_

live/include/alibabacloud/live/model/SetCasterConfigRequest.h

@@ -46,6 +46,10 @@ public:
 	void setTranscodeConfig(const std::string &transcodeConfig);
 	std::string getCasterName() const;
 	void setCasterName(const std::string &casterName);
+	bool getAutoSwitchUrgentOn() const;
+	void setAutoSwitchUrgentOn(bool autoSwitchUrgentOn);
+	std::string getAutoSwitchUrgentConfig() const;
+	void setAutoSwitchUrgentConfig(const std::string &autoSwitchUrgentConfig);
 	std::string getUrgentLiveStreamUrl() const;
 	void setUrgentLiveStreamUrl(const std::string &urgentLiveStreamUrl);
 	std::string getSideOutputUrl() const;
@@ -76,6 +80,8 @@ private:
 	std::string urgentMaterialId_;
 	std::string transcodeConfig_;
 	std::string casterName_;
+	bool autoSwitchUrgentOn_;
+	std::string autoSwitchUrgentConfig_;
 	std::string urgentLiveStreamUrl_;
 	std::string sideOutputUrl_;
 	std::string syncGroupsConfig_;

live/src/LiveClient.cc

@@ -2139,6 +2139,42 @@ LiveClient::CreateMixStreamOutcomeCallable LiveClient::createMixStreamCallable(c
 	return task->get_future();
 }
 
+LiveClient::CreateRoomRealTimeStreamAddressOutcome LiveClient::createRoomRealTimeStreamAddress(const CreateRoomRealTimeStreamAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateRoomRealTimeStreamAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateRoomRealTimeStreamAddressOutcome(CreateRoomRealTimeStreamAddressResult(outcome.result()));
+	else
+		return CreateRoomRealTimeStreamAddressOutcome(outcome.error());
+}
+
+void LiveClient::createRoomRealTimeStreamAddressAsync(const CreateRoomRealTimeStreamAddressRequest& request, const CreateRoomRealTimeStreamAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createRoomRealTimeStreamAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::CreateRoomRealTimeStreamAddressOutcomeCallable LiveClient::createRoomRealTimeStreamAddressCallable(const CreateRoomRealTimeStreamAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateRoomRealTimeStreamAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->createRoomRealTimeStreamAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DeleteCasterOutcome LiveClient::deleteCaster(const DeleteCasterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5343,6 +5379,42 @@ LiveClient::DescribeLiveDomainLogOutcomeCallable LiveClient::describeLiveDomainL
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainLogExTtlOutcome LiveClient::describeLiveDomainLogExTtl(const DescribeLiveDomainLogExTtlRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainLogExTtlOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainLogExTtlOutcome(DescribeLiveDomainLogExTtlResult(outcome.result()));
+	else
+		return DescribeLiveDomainLogExTtlOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainLogExTtlAsync(const DescribeLiveDomainLogExTtlRequest& request, const DescribeLiveDomainLogExTtlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainLogExTtl(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainLogExTtlOutcomeCallable LiveClient::describeLiveDomainLogExTtlCallable(const DescribeLiveDomainLogExTtlRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainLogExTtlOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainLogExTtl(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainMappingOutcome LiveClient::describeLiveDomainMapping(const DescribeLiveDomainMappingRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6135,6 +6207,42 @@ LiveClient::DescribeLiveGrtnDurationOutcomeCallable LiveClient::describeLiveGrtn
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveGrtnTrafficUsageOutcome LiveClient::describeLiveGrtnTrafficUsage(const DescribeLiveGrtnTrafficUsageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveGrtnTrafficUsageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveGrtnTrafficUsageOutcome(DescribeLiveGrtnTrafficUsageResult(outcome.result()));
+	else
+		return DescribeLiveGrtnTrafficUsageOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveGrtnTrafficUsageAsync(const DescribeLiveGrtnTrafficUsageRequest& request, const DescribeLiveGrtnTrafficUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveGrtnTrafficUsage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveGrtnTrafficUsageOutcomeCallable LiveClient::describeLiveGrtnTrafficUsageCallable(const DescribeLiveGrtnTrafficUsageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveGrtnTrafficUsageOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveGrtnTrafficUsage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveHttpsDomainListOutcome LiveClient::describeLiveHttpsDomainList(const DescribeLiveHttpsDomainListRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7467,6 +7575,42 @@ LiveClient::DescribeLiveStreamTranscodeInfoOutcomeCallable LiveClient::describeL
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveStreamTranscodeMetricDataOutcome LiveClient::describeLiveStreamTranscodeMetricData(const DescribeLiveStreamTranscodeMetricDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveStreamTranscodeMetricDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveStreamTranscodeMetricDataOutcome(DescribeLiveStreamTranscodeMetricDataResult(outcome.result()));
+	else
+		return DescribeLiveStreamTranscodeMetricDataOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveStreamTranscodeMetricDataAsync(const DescribeLiveStreamTranscodeMetricDataRequest& request, const DescribeLiveStreamTranscodeMetricDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveStreamTranscodeMetricData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveStreamTranscodeMetricDataOutcomeCallable LiveClient::describeLiveStreamTranscodeMetricDataCallable(const DescribeLiveStreamTranscodeMetricDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveStreamTranscodeMetricDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveStreamTranscodeMetricData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveStreamTranscodeStreamNumOutcome LiveClient::describeLiveStreamTranscodeStreamNum(const DescribeLiveStreamTranscodeStreamNumRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/CreateEventSubRequest.cc

@@ -25,33 +25,6 @@ CreateEventSubRequest::CreateEventSubRequest()
 
 CreateEventSubRequest::~CreateEventSubRequest() {}
 
-int CreateEventSubRequest::getRole() const {
-  return role_;
-}
-
-void CreateEventSubRequest::setRole(int role) {
-  role_ = role;
-  setParameter(std::string("Role"), std::to_string(role));
-}
-
-std::string CreateEventSubRequest::getClientToken() const {
-  return clientToken_;
-}
-
-void CreateEventSubRequest::setClientToken(const std::string &clientToken) {
-  clientToken_ = clientToken;
-  setParameter(std::string("ClientToken"), clientToken);
-}
-
-bool CreateEventSubRequest::getNeedCallbackAuthorization() const {
-  return needCallbackAuthorization_;
-}
-
-void CreateEventSubRequest::setNeedCallbackAuthorization(bool needCallbackAuthorization) {
-  needCallbackAuthorization_ = needCallbackAuthorization;
-  setParameter(std::string("NeedCallbackAuthorization"), needCallbackAuthorization ? "true" : "false");
-}
-
 std::vector<std::string> CreateEventSubRequest::getUsers() const {
   return users_;
 }

live/src/model/CreateRoomRealTimeStreamAddressRequest.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/CreateRoomRealTimeStreamAddressRequest.h>
+
+using AlibabaCloud::Live::Model::CreateRoomRealTimeStreamAddressRequest;
+
+CreateRoomRealTimeStreamAddressRequest::CreateRoomRealTimeStreamAddressRequest()
+    : RpcServiceRequest("live", "2016-11-01", "CreateRoomRealTimeStreamAddress") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateRoomRealTimeStreamAddressRequest::~CreateRoomRealTimeStreamAddressRequest() {}
+
+int CreateRoomRealTimeStreamAddressRequest::getExpireTime() const {
+  return expireTime_;
+}
+
+void CreateRoomRealTimeStreamAddressRequest::setExpireTime(int expireTime) {
+  expireTime_ = expireTime;
+  setParameter(std::string("ExpireTime"), std::to_string(expireTime));
+}
+
+std::string CreateRoomRealTimeStreamAddressRequest::getUserId() const {
+  return userId_;
+}
+
+void CreateRoomRealTimeStreamAddressRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string CreateRoomRealTimeStreamAddressRequest::getAppId() const {
+  return appId_;
+}
+
+void CreateRoomRealTimeStreamAddressRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+std::string CreateRoomRealTimeStreamAddressRequest::getDisplayName() const {
+  return displayName_;
+}
+
+void CreateRoomRealTimeStreamAddressRequest::setDisplayName(const std::string &displayName) {
+  displayName_ = displayName;
+  setParameter(std::string("DisplayName"), displayName);
+}
+
+std::string CreateRoomRealTimeStreamAddressRequest::getChannelId() const {
+  return channelId_;
+}
+
+void CreateRoomRealTimeStreamAddressRequest::setChannelId(const std::string &channelId) {
+  channelId_ = channelId;
+  setParameter(std::string("ChannelId"), channelId);
+}
+

live/src/model/CreateRoomRealTimeStreamAddressResult.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/live/model/CreateRoomRealTimeStreamAddressResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+CreateRoomRealTimeStreamAddressResult::CreateRoomRealTimeStreamAddressResult() :
+	ServiceResult()
+{}
+
+CreateRoomRealTimeStreamAddressResult::CreateRoomRealTimeStreamAddressResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateRoomRealTimeStreamAddressResult::~CreateRoomRealTimeStreamAddressResult()
+{}
+
+void CreateRoomRealTimeStreamAddressResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["RtmpAddress"].isNull())
+		rtmpAddress_ = value["RtmpAddress"].asString();
+
+}
+
+std::string CreateRoomRealTimeStreamAddressResult::getRtmpAddress()const
+{
+	return rtmpAddress_;
+}
+

live/src/model/DescribeCasterConfigResult.cc

@@ -107,6 +107,10 @@ void DescribeCasterConfigResult::parse(const std::string &payload)
 		sideOutputUrlList_ = value["SideOutputUrlList"].asString();
 	if(!value["SideOutputUrl"].isNull())
 		sideOutputUrl_ = value["SideOutputUrl"].asString();
+	if(!value["AutoSwitchUrgentOn"].isNull())
+		autoSwitchUrgentOn_ = value["AutoSwitchUrgentOn"].asString();
+	if(!value["AutoSwitchUrgentConfig"].isNull())
+		autoSwitchUrgentConfig_ = value["AutoSwitchUrgentConfig"].asString();
 
 }
 
@@ -125,6 +129,11 @@ std::string DescribeCasterConfigResult::getUrgentImageUrl()const
 	return urgentImageUrl_;
 }
 
+std::string DescribeCasterConfigResult::getAutoSwitchUrgentConfig()const
+{
+	return autoSwitchUrgentConfig_;
+}
+
 std::string DescribeCasterConfigResult::getUrgentMaterialId()const
 {
 	return urgentMaterialId_;
@@ -175,6 +184,11 @@ int DescribeCasterConfigResult::getProgramEffect()const
 	return programEffect_;
 }
 
+std::string DescribeCasterConfigResult::getAutoSwitchUrgentOn()const
+{
+	return autoSwitchUrgentOn_;
+}
+
 std::vector<DescribeCasterConfigResult::SyncGroup> DescribeCasterConfigResult::getSyncGroupsConfig()const
 {
 	return syncGroupsConfig_;

live/src/model/DescribeLiveDomainLogExTtlRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/DescribeLiveDomainLogExTtlRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainLogExTtlRequest;
+
+DescribeLiveDomainLogExTtlRequest::DescribeLiveDomainLogExTtlRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainLogExTtl") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainLogExTtlRequest::~DescribeLiveDomainLogExTtlRequest() {}
+
+std::string DescribeLiveDomainLogExTtlRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+long DescribeLiveDomainLogExTtlRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeLiveDomainLogExTtlRequest::getLogType() const {
+  return logType_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setLogType(const std::string &logType) {
+  logType_ = logType;
+  setParameter(std::string("LogType"), logType);
+}
+
+long DescribeLiveDomainLogExTtlRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeLiveDomainLogExTtlRequest::getDomainName() const {
+  return domainName_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+std::string DescribeLiveDomainLogExTtlRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+long DescribeLiveDomainLogExTtlRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLiveDomainLogExTtlRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveDomainLogExTtlResult.cc

@@ -0,0 +1,87 @@
+/*
+ * 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/DescribeLiveDomainLogExTtlResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainLogExTtlResult::DescribeLiveDomainLogExTtlResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainLogExTtlResult::DescribeLiveDomainLogExTtlResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainLogExTtlResult::~DescribeLiveDomainLogExTtlResult()
+{}
+
+void DescribeLiveDomainLogExTtlResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDomainLogDetailsNode = value["DomainLogDetails"]["DomainLogDetail"];
+	for (auto valueDomainLogDetailsDomainLogDetail : allDomainLogDetailsNode)
+	{
+		DomainLogDetail domainLogDetailsObject;
+		if(!valueDomainLogDetailsDomainLogDetail["LogCount"].isNull())
+			domainLogDetailsObject.logCount = std::stol(valueDomainLogDetailsDomainLogDetail["LogCount"].asString());
+		auto allLogInfosNode = valueDomainLogDetailsDomainLogDetail["LogInfos"]["LogInfoDetail"];
+		for (auto valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail : allLogInfosNode)
+		{
+			DomainLogDetail::LogInfoDetail logInfosObject;
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["EndTime"].isNull())
+				logInfosObject.endTime = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["EndTime"].asString();
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogSize"].isNull())
+				logInfosObject.logSize = std::stol(valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogSize"].asString());
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["StartTime"].isNull())
+				logInfosObject.startTime = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["StartTime"].asString();
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogName"].isNull())
+				logInfosObject.logName = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogName"].asString();
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogPath"].isNull())
+				logInfosObject.logPath = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogPath"].asString();
+			domainLogDetailsObject.logInfos.push_back(logInfosObject);
+		}
+		auto pageInfosNode = value["PageInfos"];
+		if(!pageInfosNode["PageIndex"].isNull())
+			domainLogDetailsObject.pageInfos.pageIndex = std::stol(pageInfosNode["PageIndex"].asString());
+		if(!pageInfosNode["PageSize"].isNull())
+			domainLogDetailsObject.pageInfos.pageSize = std::stol(pageInfosNode["PageSize"].asString());
+		if(!pageInfosNode["Total"].isNull())
+			domainLogDetailsObject.pageInfos.total = std::stol(pageInfosNode["Total"].asString());
+		domainLogDetails_.push_back(domainLogDetailsObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+
+}
+
+std::string DescribeLiveDomainLogExTtlResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::vector<DescribeLiveDomainLogExTtlResult::DomainLogDetail> DescribeLiveDomainLogExTtlResult::getDomainLogDetails()const
+{
+	return domainLogDetails_;
+}
+

live/src/model/DescribeLiveGrtnTrafficUsageRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/DescribeLiveGrtnTrafficUsageRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveGrtnTrafficUsageRequest;
+
+DescribeLiveGrtnTrafficUsageRequest::DescribeLiveGrtnTrafficUsageRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLiveGrtnTrafficUsage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveGrtnTrafficUsageRequest::~DescribeLiveGrtnTrafficUsageRequest() {}
+
+std::string DescribeLiveGrtnTrafficUsageRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeLiveGrtnTrafficUsageRequest::getArea() const {
+  return area_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setArea(const std::string &area) {
+  area_ = area;
+  setParameter(std::string("Area"), area);
+}
+
+std::string DescribeLiveGrtnTrafficUsageRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+long DescribeLiveGrtnTrafficUsageRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeLiveGrtnTrafficUsageRequest::getField() const {
+  return field_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setField(const std::string &field) {
+  field_ = field;
+  setParameter(std::string("Field"), field);
+}
+
+std::string DescribeLiveGrtnTrafficUsageRequest::getAppId() const {
+  return appId_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+std::string DescribeLiveGrtnTrafficUsageRequest::getInterval() const {
+  return interval_;
+}
+
+void DescribeLiveGrtnTrafficUsageRequest::setInterval(const std::string &interval) {
+  interval_ = interval;
+  setParameter(std::string("Interval"), interval);
+}
+

live/src/model/DescribeLiveGrtnTrafficUsageResult.cc

@@ -0,0 +1,94 @@
+/*
+ * 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/DescribeLiveGrtnTrafficUsageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveGrtnTrafficUsageResult::DescribeLiveGrtnTrafficUsageResult() :
+	ServiceResult()
+{}
+
+DescribeLiveGrtnTrafficUsageResult::DescribeLiveGrtnTrafficUsageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveGrtnTrafficUsageResult::~DescribeLiveGrtnTrafficUsageResult()
+{}
+
+void DescribeLiveGrtnTrafficUsageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allUsageDataPerIntervalNode = value["UsageDataPerInterval"]["UsageData"];
+	for (auto valueUsageDataPerIntervalUsageData : allUsageDataPerIntervalNode)
+	{
+		UsageData usageDataPerIntervalObject;
+		if(!valueUsageDataPerIntervalUsageData["Value"].isNull())
+			usageDataPerIntervalObject.value = valueUsageDataPerIntervalUsageData["Value"].asString();
+		if(!valueUsageDataPerIntervalUsageData["TimeStamp"].isNull())
+			usageDataPerIntervalObject.timeStamp = valueUsageDataPerIntervalUsageData["TimeStamp"].asString();
+		usageDataPerInterval_.push_back(usageDataPerIntervalObject);
+	}
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["Filed"].isNull())
+		filed_ = value["Filed"].asString();
+	if(!value["AppId"].isNull())
+		appId_ = value["AppId"].asString();
+	if(!value["Area"].isNull())
+		area_ = value["Area"].asString();
+
+}
+
+std::vector<DescribeLiveGrtnTrafficUsageResult::UsageData> DescribeLiveGrtnTrafficUsageResult::getUsageDataPerInterval()const
+{
+	return usageDataPerInterval_;
+}
+
+std::string DescribeLiveGrtnTrafficUsageResult::getArea()const
+{
+	return area_;
+}
+
+std::string DescribeLiveGrtnTrafficUsageResult::getFiled()const
+{
+	return filed_;
+}
+
+std::string DescribeLiveGrtnTrafficUsageResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeLiveGrtnTrafficUsageResult::getAppId()const
+{
+	return appId_;
+}
+
+std::string DescribeLiveGrtnTrafficUsageResult::getStartTime()const
+{
+	return startTime_;
+}
+

live/src/model/DescribeLiveStreamTranscodeMetricDataRequest.cc

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

live/src/model/DescribeLiveStreamTranscodeMetricDataResult.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/live/model/DescribeLiveStreamTranscodeMetricDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveStreamTranscodeMetricDataResult::DescribeLiveStreamTranscodeMetricDataResult() :
+	ServiceResult()
+{}
+
+DescribeLiveStreamTranscodeMetricDataResult::DescribeLiveStreamTranscodeMetricDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveStreamTranscodeMetricDataResult::~DescribeLiveStreamTranscodeMetricDataResult()
+{}
+
+void DescribeLiveStreamTranscodeMetricDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allStreamDetailDataNode = value["StreamDetailData"]["StreamData"];
+	for (auto valueStreamDetailDataStreamData : allStreamDetailDataNode)
+	{
+		StreamData streamDetailDataObject;
+		if(!valueStreamDetailDataStreamData["AppName"].isNull())
+			streamDetailDataObject.appName = valueStreamDetailDataStreamData["AppName"].asString();
+		if(!valueStreamDetailDataStreamData["StreamName"].isNull())
+			streamDetailDataObject.streamName = valueStreamDetailDataStreamData["StreamName"].asString();
+		if(!valueStreamDetailDataStreamData["Region"].isNull())
+			streamDetailDataObject.region = valueStreamDetailDataStreamData["Region"].asString();
+		if(!valueStreamDetailDataStreamData["Duration"].isNull())
+			streamDetailDataObject.duration = std::stol(valueStreamDetailDataStreamData["Duration"].asString());
+		if(!valueStreamDetailDataStreamData["Fps"].isNull())
+			streamDetailDataObject.fps = valueStreamDetailDataStreamData["Fps"].asString();
+		if(!valueStreamDetailDataStreamData["TimeStamp"].isNull())
+			streamDetailDataObject.timeStamp = valueStreamDetailDataStreamData["TimeStamp"].asString();
+		if(!valueStreamDetailDataStreamData["TranscodeType"].isNull())
+			streamDetailDataObject.transcodeType = valueStreamDetailDataStreamData["TranscodeType"].asString();
+		if(!valueStreamDetailDataStreamData["Resolution"].isNull())
+			streamDetailDataObject.resolution = valueStreamDetailDataStreamData["Resolution"].asString();
+		streamDetailData_.push_back(streamDetailDataObject);
+	}
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["NextPageToken"].isNull())
+		nextPageToken_ = value["NextPageToken"].asString();
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+
+}
+
+std::string DescribeLiveStreamTranscodeMetricDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+int DescribeLiveStreamTranscodeMetricDataResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::string DescribeLiveStreamTranscodeMetricDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeLiveStreamTranscodeMetricDataResult::getNextPageToken()const
+{
+	return nextPageToken_;
+}
+
+std::string DescribeLiveStreamTranscodeMetricDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeLiveStreamTranscodeMetricDataResult::StreamData> DescribeLiveStreamTranscodeMetricDataResult::getStreamDetailData()const
+{
+	return streamDetailData_;
+}
+

live/src/model/SetCasterConfigRequest.cc

@@ -97,6 +97,24 @@ void SetCasterConfigRequest::setCasterName(const std::string &casterName) {
   setParameter(std::string("CasterName"), casterName);
 }
 
+bool SetCasterConfigRequest::getAutoSwitchUrgentOn() const {
+  return autoSwitchUrgentOn_;
+}
+
+void SetCasterConfigRequest::setAutoSwitchUrgentOn(bool autoSwitchUrgentOn) {
+  autoSwitchUrgentOn_ = autoSwitchUrgentOn;
+  setParameter(std::string("AutoSwitchUrgentOn"), autoSwitchUrgentOn ? "true" : "false");
+}
+
+std::string SetCasterConfigRequest::getAutoSwitchUrgentConfig() const {
+  return autoSwitchUrgentConfig_;
+}
+
+void SetCasterConfigRequest::setAutoSwitchUrgentConfig(const std::string &autoSwitchUrgentConfig) {
+  autoSwitchUrgentConfig_ = autoSwitchUrgentConfig;
+  setParameter(std::string("AutoSwitchUrgentConfig"), autoSwitchUrgentConfig);
+}
+
 std::string SetCasterConfigRequest::getUrgentLiveStreamUrl() const {
   return urgentLiveStreamUrl_;
 }