Add DescribeLiveDomainCertificateInfo.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-08-19 Version: 1.36.600
+- Add DescribeLiveDomainCertificateInfo.
+
 2020-08-19 Version: 1.36.599
 - Generated 2020-08-01 for `SmartHosting`.
 

VERSION

@@ -1 +1 @@
-1.36.599
+1.36.600

live/CMakeLists.txt

@@ -61,6 +61,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/AddLiveSnapshotDetectPornConfigResult.h
 	include/alibabacloud/live/model/AddLiveStreamTranscodeRequest.h
 	include/alibabacloud/live/model/AddLiveStreamTranscodeResult.h
+	include/alibabacloud/live/model/AddRtsLiveStreamTranscodeRequest.h
+	include/alibabacloud/live/model/AddRtsLiveStreamTranscodeResult.h
 	include/alibabacloud/live/model/AddTrancodeSEIRequest.h
 	include/alibabacloud/live/model/AddTrancodeSEIResult.h
 	include/alibabacloud/live/model/AllowPushStreamRequest.h
@@ -199,12 +201,16 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainBpsDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainBpsDataByTimeStampRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainBpsDataByTimeStampResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainConfigsRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainConfigsResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainDetailRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainDetailResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainFrameRateAndBitRateDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainFrameRateAndBitRateDataResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainLimitRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainLimitResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainMappingRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainMappingResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainOnlineUserNumRequest.h
@@ -225,14 +231,14 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainRecordDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainSnapshotDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainSnapshotDataResult.h
+	include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataRequest.h
+	include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainTrafficDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainTrafficDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDomainTranscodeDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDomainTranscodeDataResult.h
 	include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigRequest.h
 	include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigResult.h
-	include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h
-	include/alibabacloud/live/model/DescribeLivePullStreamConfigResult.h
 	include/alibabacloud/live/model/DescribeLiveRealtimeDeliveryAccRequest.h
 	include/alibabacloud/live/model/DescribeLiveRealtimeDeliveryAccResult.h
 	include/alibabacloud/live/model/DescribeLiveRealtimeLogAuthorizedRequest.h
@@ -460,6 +466,8 @@ set(live_src
 	src/model/AddLiveSnapshotDetectPornConfigResult.cc
 	src/model/AddLiveStreamTranscodeRequest.cc
 	src/model/AddLiveStreamTranscodeResult.cc
+	src/model/AddRtsLiveStreamTranscodeRequest.cc
+	src/model/AddRtsLiveStreamTranscodeResult.cc
 	src/model/AddTrancodeSEIRequest.cc
 	src/model/AddTrancodeSEIResult.cc
 	src/model/AllowPushStreamRequest.cc
@@ -598,12 +606,16 @@ set(live_src
 	src/model/DescribeLiveDomainBpsDataResult.cc
 	src/model/DescribeLiveDomainBpsDataByTimeStampRequest.cc
 	src/model/DescribeLiveDomainBpsDataByTimeStampResult.cc
+	src/model/DescribeLiveDomainCertificateInfoRequest.cc
+	src/model/DescribeLiveDomainCertificateInfoResult.cc
 	src/model/DescribeLiveDomainConfigsRequest.cc
 	src/model/DescribeLiveDomainConfigsResult.cc
 	src/model/DescribeLiveDomainDetailRequest.cc
 	src/model/DescribeLiveDomainDetailResult.cc
 	src/model/DescribeLiveDomainFrameRateAndBitRateDataRequest.cc
 	src/model/DescribeLiveDomainFrameRateAndBitRateDataResult.cc
+	src/model/DescribeLiveDomainLimitRequest.cc
+	src/model/DescribeLiveDomainLimitResult.cc
 	src/model/DescribeLiveDomainMappingRequest.cc
 	src/model/DescribeLiveDomainMappingResult.cc
 	src/model/DescribeLiveDomainOnlineUserNumRequest.cc
@@ -624,14 +636,14 @@ set(live_src
 	src/model/DescribeLiveDomainRecordDataResult.cc
 	src/model/DescribeLiveDomainSnapshotDataRequest.cc
 	src/model/DescribeLiveDomainSnapshotDataResult.cc
+	src/model/DescribeLiveDomainTimeShiftDataRequest.cc
+	src/model/DescribeLiveDomainTimeShiftDataResult.cc
 	src/model/DescribeLiveDomainTrafficDataRequest.cc
 	src/model/DescribeLiveDomainTrafficDataResult.cc
 	src/model/DescribeLiveDomainTranscodeDataRequest.cc
 	src/model/DescribeLiveDomainTranscodeDataResult.cc
 	src/model/DescribeLiveLazyPullStreamConfigRequest.cc
 	src/model/DescribeLiveLazyPullStreamConfigResult.cc
-	src/model/DescribeLivePullStreamConfigRequest.cc
-	src/model/DescribeLivePullStreamConfigResult.cc
 	src/model/DescribeLiveRealtimeDeliveryAccRequest.cc
 	src/model/DescribeLiveRealtimeDeliveryAccResult.cc
 	src/model/DescribeLiveRealtimeLogAuthorizedRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -62,6 +62,8 @@
 #include "model/AddLiveSnapshotDetectPornConfigResult.h"
 #include "model/AddLiveStreamTranscodeRequest.h"
 #include "model/AddLiveStreamTranscodeResult.h"
+#include "model/AddRtsLiveStreamTranscodeRequest.h"
+#include "model/AddRtsLiveStreamTranscodeResult.h"
 #include "model/AddTrancodeSEIRequest.h"
 #include "model/AddTrancodeSEIResult.h"
 #include "model/AllowPushStreamRequest.h"
@@ -200,12 +202,16 @@
 #include "model/DescribeLiveDomainBpsDataResult.h"
 #include "model/DescribeLiveDomainBpsDataByTimeStampRequest.h"
 #include "model/DescribeLiveDomainBpsDataByTimeStampResult.h"
+#include "model/DescribeLiveDomainCertificateInfoRequest.h"
+#include "model/DescribeLiveDomainCertificateInfoResult.h"
 #include "model/DescribeLiveDomainConfigsRequest.h"
 #include "model/DescribeLiveDomainConfigsResult.h"
 #include "model/DescribeLiveDomainDetailRequest.h"
 #include "model/DescribeLiveDomainDetailResult.h"
 #include "model/DescribeLiveDomainFrameRateAndBitRateDataRequest.h"
 #include "model/DescribeLiveDomainFrameRateAndBitRateDataResult.h"
+#include "model/DescribeLiveDomainLimitRequest.h"
+#include "model/DescribeLiveDomainLimitResult.h"
 #include "model/DescribeLiveDomainMappingRequest.h"
 #include "model/DescribeLiveDomainMappingResult.h"
 #include "model/DescribeLiveDomainOnlineUserNumRequest.h"
@@ -226,14 +232,14 @@
 #include "model/DescribeLiveDomainRecordDataResult.h"
 #include "model/DescribeLiveDomainSnapshotDataRequest.h"
 #include "model/DescribeLiveDomainSnapshotDataResult.h"
+#include "model/DescribeLiveDomainTimeShiftDataRequest.h"
+#include "model/DescribeLiveDomainTimeShiftDataResult.h"
 #include "model/DescribeLiveDomainTrafficDataRequest.h"
 #include "model/DescribeLiveDomainTrafficDataResult.h"
 #include "model/DescribeLiveDomainTranscodeDataRequest.h"
 #include "model/DescribeLiveDomainTranscodeDataResult.h"
 #include "model/DescribeLiveLazyPullStreamConfigRequest.h"
 #include "model/DescribeLiveLazyPullStreamConfigResult.h"
-#include "model/DescribeLivePullStreamConfigRequest.h"
-#include "model/DescribeLivePullStreamConfigResult.h"
 #include "model/DescribeLiveRealtimeDeliveryAccRequest.h"
 #include "model/DescribeLiveRealtimeDeliveryAccResult.h"
 #include "model/DescribeLiveRealtimeLogAuthorizedRequest.h"
@@ -487,6 +493,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddLiveStreamTranscodeResult> AddLiveStreamTranscodeOutcome;
 			typedef std::future<AddLiveStreamTranscodeOutcome> AddLiveStreamTranscodeOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::AddLiveStreamTranscodeRequest&, const AddLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveStreamTranscodeAsyncHandler;
+			typedef Outcome<Error, Model::AddRtsLiveStreamTranscodeResult> AddRtsLiveStreamTranscodeOutcome;
+			typedef std::future<AddRtsLiveStreamTranscodeOutcome> AddRtsLiveStreamTranscodeOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::AddRtsLiveStreamTranscodeRequest&, const AddRtsLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddRtsLiveStreamTranscodeAsyncHandler;
 			typedef Outcome<Error, Model::AddTrancodeSEIResult> AddTrancodeSEIOutcome;
 			typedef std::future<AddTrancodeSEIOutcome> AddTrancodeSEIOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::AddTrancodeSEIRequest&, const AddTrancodeSEIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTrancodeSEIAsyncHandler;
@@ -694,6 +703,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainBpsDataByTimeStampResult> DescribeLiveDomainBpsDataByTimeStampOutcome;
 			typedef std::future<DescribeLiveDomainBpsDataByTimeStampOutcome> DescribeLiveDomainBpsDataByTimeStampOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainBpsDataByTimeStampRequest&, const DescribeLiveDomainBpsDataByTimeStampOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainBpsDataByTimeStampAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainCertificateInfoResult> DescribeLiveDomainCertificateInfoOutcome;
+			typedef std::future<DescribeLiveDomainCertificateInfoOutcome> DescribeLiveDomainCertificateInfoOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainCertificateInfoRequest&, const DescribeLiveDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainCertificateInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainConfigsResult> DescribeLiveDomainConfigsOutcome;
 			typedef std::future<DescribeLiveDomainConfigsOutcome> DescribeLiveDomainConfigsOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainConfigsRequest&, const DescribeLiveDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainConfigsAsyncHandler;
@@ -703,6 +715,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainFrameRateAndBitRateDataResult> DescribeLiveDomainFrameRateAndBitRateDataOutcome;
 			typedef std::future<DescribeLiveDomainFrameRateAndBitRateDataOutcome> DescribeLiveDomainFrameRateAndBitRateDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest&, const DescribeLiveDomainFrameRateAndBitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainFrameRateAndBitRateDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainLimitResult> DescribeLiveDomainLimitOutcome;
+			typedef std::future<DescribeLiveDomainLimitOutcome> DescribeLiveDomainLimitOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainLimitRequest&, const DescribeLiveDomainLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainLimitAsyncHandler;
 			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;
@@ -733,6 +748,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDomainSnapshotDataResult> DescribeLiveDomainSnapshotDataOutcome;
 			typedef std::future<DescribeLiveDomainSnapshotDataOutcome> DescribeLiveDomainSnapshotDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainSnapshotDataRequest&, const DescribeLiveDomainSnapshotDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainSnapshotDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDomainTimeShiftDataResult> DescribeLiveDomainTimeShiftDataOutcome;
+			typedef std::future<DescribeLiveDomainTimeShiftDataOutcome> DescribeLiveDomainTimeShiftDataOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainTimeShiftDataRequest&, const DescribeLiveDomainTimeShiftDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainTimeShiftDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDomainTrafficDataResult> DescribeLiveDomainTrafficDataOutcome;
 			typedef std::future<DescribeLiveDomainTrafficDataOutcome> DescribeLiveDomainTrafficDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainTrafficDataRequest&, const DescribeLiveDomainTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainTrafficDataAsyncHandler;
@@ -742,9 +760,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveLazyPullStreamConfigResult> DescribeLiveLazyPullStreamConfigOutcome;
 			typedef std::future<DescribeLiveLazyPullStreamConfigOutcome> DescribeLiveLazyPullStreamConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveLazyPullStreamConfigRequest&, const DescribeLiveLazyPullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveLazyPullStreamConfigAsyncHandler;
-			typedef Outcome<Error, Model::DescribeLivePullStreamConfigResult> DescribeLivePullStreamConfigOutcome;
-			typedef std::future<DescribeLivePullStreamConfigOutcome> DescribeLivePullStreamConfigOutcomeCallable;
-			typedef std::function<void(const LiveClient*, const Model::DescribeLivePullStreamConfigRequest&, const DescribeLivePullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePullStreamConfigAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveRealtimeDeliveryAccResult> DescribeLiveRealtimeDeliveryAccOutcome;
 			typedef std::future<DescribeLiveRealtimeDeliveryAccOutcome> DescribeLiveRealtimeDeliveryAccOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveRealtimeDeliveryAccRequest&, const DescribeLiveRealtimeDeliveryAccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRealtimeDeliveryAccAsyncHandler;
@@ -1086,6 +1101,9 @@ namespace AlibabaCloud
 			AddLiveStreamTranscodeOutcome addLiveStreamTranscode(const Model::AddLiveStreamTranscodeRequest &request)const;
 			void addLiveStreamTranscodeAsync(const Model::AddLiveStreamTranscodeRequest& request, const AddLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddLiveStreamTranscodeOutcomeCallable addLiveStreamTranscodeCallable(const Model::AddLiveStreamTranscodeRequest& request) const;
+			AddRtsLiveStreamTranscodeOutcome addRtsLiveStreamTranscode(const Model::AddRtsLiveStreamTranscodeRequest &request)const;
+			void addRtsLiveStreamTranscodeAsync(const Model::AddRtsLiveStreamTranscodeRequest& request, const AddRtsLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddRtsLiveStreamTranscodeOutcomeCallable addRtsLiveStreamTranscodeCallable(const Model::AddRtsLiveStreamTranscodeRequest& request) const;
 			AddTrancodeSEIOutcome addTrancodeSEI(const Model::AddTrancodeSEIRequest &request)const;
 			void addTrancodeSEIAsync(const Model::AddTrancodeSEIRequest& request, const AddTrancodeSEIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddTrancodeSEIOutcomeCallable addTrancodeSEICallable(const Model::AddTrancodeSEIRequest& request) const;
@@ -1293,6 +1311,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainBpsDataByTimeStampOutcome describeLiveDomainBpsDataByTimeStamp(const Model::DescribeLiveDomainBpsDataByTimeStampRequest &request)const;
 			void describeLiveDomainBpsDataByTimeStampAsync(const Model::DescribeLiveDomainBpsDataByTimeStampRequest& request, const DescribeLiveDomainBpsDataByTimeStampAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainBpsDataByTimeStampOutcomeCallable describeLiveDomainBpsDataByTimeStampCallable(const Model::DescribeLiveDomainBpsDataByTimeStampRequest& request) const;
+			DescribeLiveDomainCertificateInfoOutcome describeLiveDomainCertificateInfo(const Model::DescribeLiveDomainCertificateInfoRequest &request)const;
+			void describeLiveDomainCertificateInfoAsync(const Model::DescribeLiveDomainCertificateInfoRequest& request, const DescribeLiveDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainCertificateInfoOutcomeCallable describeLiveDomainCertificateInfoCallable(const Model::DescribeLiveDomainCertificateInfoRequest& request) const;
 			DescribeLiveDomainConfigsOutcome describeLiveDomainConfigs(const Model::DescribeLiveDomainConfigsRequest &request)const;
 			void describeLiveDomainConfigsAsync(const Model::DescribeLiveDomainConfigsRequest& request, const DescribeLiveDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainConfigsOutcomeCallable describeLiveDomainConfigsCallable(const Model::DescribeLiveDomainConfigsRequest& request) const;
@@ -1302,6 +1323,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainFrameRateAndBitRateDataOutcome describeLiveDomainFrameRateAndBitRateData(const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest &request)const;
 			void describeLiveDomainFrameRateAndBitRateDataAsync(const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest& request, const DescribeLiveDomainFrameRateAndBitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainFrameRateAndBitRateDataOutcomeCallable describeLiveDomainFrameRateAndBitRateDataCallable(const Model::DescribeLiveDomainFrameRateAndBitRateDataRequest& request) const;
+			DescribeLiveDomainLimitOutcome describeLiveDomainLimit(const Model::DescribeLiveDomainLimitRequest &request)const;
+			void describeLiveDomainLimitAsync(const Model::DescribeLiveDomainLimitRequest& request, const DescribeLiveDomainLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainLimitOutcomeCallable describeLiveDomainLimitCallable(const Model::DescribeLiveDomainLimitRequest& 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;
@@ -1332,6 +1356,9 @@ namespace AlibabaCloud
 			DescribeLiveDomainSnapshotDataOutcome describeLiveDomainSnapshotData(const Model::DescribeLiveDomainSnapshotDataRequest &request)const;
 			void describeLiveDomainSnapshotDataAsync(const Model::DescribeLiveDomainSnapshotDataRequest& request, const DescribeLiveDomainSnapshotDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainSnapshotDataOutcomeCallable describeLiveDomainSnapshotDataCallable(const Model::DescribeLiveDomainSnapshotDataRequest& request) const;
+			DescribeLiveDomainTimeShiftDataOutcome describeLiveDomainTimeShiftData(const Model::DescribeLiveDomainTimeShiftDataRequest &request)const;
+			void describeLiveDomainTimeShiftDataAsync(const Model::DescribeLiveDomainTimeShiftDataRequest& request, const DescribeLiveDomainTimeShiftDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDomainTimeShiftDataOutcomeCallable describeLiveDomainTimeShiftDataCallable(const Model::DescribeLiveDomainTimeShiftDataRequest& request) const;
 			DescribeLiveDomainTrafficDataOutcome describeLiveDomainTrafficData(const Model::DescribeLiveDomainTrafficDataRequest &request)const;
 			void describeLiveDomainTrafficDataAsync(const Model::DescribeLiveDomainTrafficDataRequest& request, const DescribeLiveDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDomainTrafficDataOutcomeCallable describeLiveDomainTrafficDataCallable(const Model::DescribeLiveDomainTrafficDataRequest& request) const;
@@ -1341,9 +1368,6 @@ namespace AlibabaCloud
 			DescribeLiveLazyPullStreamConfigOutcome describeLiveLazyPullStreamConfig(const Model::DescribeLiveLazyPullStreamConfigRequest &request)const;
 			void describeLiveLazyPullStreamConfigAsync(const Model::DescribeLiveLazyPullStreamConfigRequest& request, const DescribeLiveLazyPullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveLazyPullStreamConfigOutcomeCallable describeLiveLazyPullStreamConfigCallable(const Model::DescribeLiveLazyPullStreamConfigRequest& request) const;
-			DescribeLivePullStreamConfigOutcome describeLivePullStreamConfig(const Model::DescribeLivePullStreamConfigRequest &request)const;
-			void describeLivePullStreamConfigAsync(const Model::DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeLivePullStreamConfigOutcomeCallable describeLivePullStreamConfigCallable(const Model::DescribeLivePullStreamConfigRequest& request) const;
 			DescribeLiveRealtimeDeliveryAccOutcome describeLiveRealtimeDeliveryAcc(const Model::DescribeLiveRealtimeDeliveryAccRequest &request)const;
 			void describeLiveRealtimeDeliveryAccAsync(const Model::DescribeLiveRealtimeDeliveryAccRequest& request, const DescribeLiveRealtimeDeliveryAccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveRealtimeDeliveryAccOutcomeCallable describeLiveRealtimeDeliveryAccCallable(const Model::DescribeLiveRealtimeDeliveryAccRequest& request) const;

live/include/alibabacloud/live/model/AddLiveAppSnapshotConfigRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setSequenceOssObject(const std::string& sequenceOssObject);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getCallback()const;
+				void setCallback(const std::string& callback);
 
             private:
 				int timeInterval_;
@@ -64,6 +66,7 @@ namespace AlibabaCloud
 				std::string domainName_;
 				std::string sequenceOssObject_;
 				long ownerId_;
+				std::string callback_;
 
 			};
 		}

live/include/alibabacloud/live/model/AddLivePullStreamInfoConfigRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setAppName(const std::string& appName);
 				std::string getStreamName()const;
 				void setStreamName(const std::string& streamName);
+				std::string getPullAlways()const;
+				void setPullAlways(const std::string& pullAlways);
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				std::string getEndTime()const;
@@ -54,6 +56,7 @@ namespace AlibabaCloud
 				std::string startTime_;
 				std::string appName_;
 				std::string streamName_;
+				std::string pullAlways_;
 				std::string domainName_;
 				std::string endTime_;
 				long ownerId_;

live/include/alibabacloud/live/model/AddRtsLiveStreamTranscodeRequest.h

@@ -0,0 +1,99 @@
+/*
+ * 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_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT AddRtsLiveStreamTranscodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddRtsLiveStreamTranscodeRequest();
+				~AddRtsLiveStreamTranscodeRequest();
+
+				std::string get_Template()const;
+				void set_Template(const std::string& _template);
+				bool getDeleteBframes()const;
+				void setDeleteBframes(bool deleteBframes);
+				std::string getGop()const;
+				void setGop(const std::string& gop);
+				bool getOpus()const;
+				void setOpus(bool opus);
+				std::string getAudioCodec()const;
+				void setAudioCodec(const std::string& audioCodec);
+				std::string getTemplateType()const;
+				void setTemplateType(const std::string& templateType);
+				std::string getAudioProfile()const;
+				void setAudioProfile(const std::string& audioProfile);
+				int getHeight()const;
+				void setHeight(int height);
+				std::string getApp()const;
+				void setApp(const std::string& app);
+				int getAudioChannelNum()const;
+				void setAudioChannelNum(int audioChannelNum);
+				int getProfile()const;
+				void setProfile(int profile);
+				int getFPS()const;
+				void setFPS(int fPS);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getAudioRate()const;
+				void setAudioRate(int audioRate);
+				int getAudioBitrate()const;
+				void setAudioBitrate(int audioBitrate);
+				std::string getDomain()const;
+				void setDomain(const std::string& domain);
+				int getWidth()const;
+				void setWidth(int width);
+				int getVideoBitrate()const;
+				void setVideoBitrate(int videoBitrate);
+
+            private:
+				std::string _template_;
+				bool deleteBframes_;
+				std::string gop_;
+				bool opus_;
+				std::string audioCodec_;
+				std::string templateType_;
+				std::string audioProfile_;
+				int height_;
+				std::string app_;
+				int audioChannelNum_;
+				int profile_;
+				int fPS_;
+				long ownerId_;
+				int audioRate_;
+				int audioBitrate_;
+				std::string domain_;
+				int width_;
+				int videoBitrate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_

live/include/alibabacloud/live/model/AddRtsLiveStreamTranscodeResult.h

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

live/include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h → live/include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
-#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFOREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFOREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,27 +28,24 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_LIVE_EXPORT DescribeLivePullStreamConfigRequest : public RpcServiceRequest
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainCertificateInfoRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeLivePullStreamConfigRequest();
-				~DescribeLivePullStreamConfigRequest();
+				DescribeLiveDomainCertificateInfoRequest();
+				~DescribeLiveDomainCertificateInfoRequest();
 
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getSecurityToken()const;
-				void setSecurityToken(const std::string& securityToken);
 
             private:
 				std::string domainName_;
 				long ownerId_;
-				std::string securityToken_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGREQUEST_H_
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFOREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoResult.h

@@ -0,0 +1,64 @@
+/*
+ * 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_DESCRIBELIVEDOMAINCERTIFICATEINFORESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFORESULT_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 DescribeLiveDomainCertificateInfoResult : public ServiceResult
+			{
+			public:
+				struct CertInfo
+				{
+					std::string status;
+					std::string certLife;
+					std::string domainName;
+					std::string sSLPub;
+					std::string certDomainName;
+					std::string certOrg;
+					std::string certType;
+					std::string certExpireTime;
+					std::string certName;
+					std::string sSLProtocol;
+				};
+
+
+				DescribeLiveDomainCertificateInfoResult();
+				explicit DescribeLiveDomainCertificateInfoResult(const std::string &payload);
+				~DescribeLiveDomainCertificateInfoResult();
+				std::vector<CertInfo> getCertInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<CertInfo> certInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINCERTIFICATEINFORESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainLimitRequest.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_DESCRIBELIVEDOMAINLIMITREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainLimitRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveDomainLimitRequest();
+				~DescribeLiveDomainLimitRequest();
+
+				std::string getLiveapiRequestFrom()const;
+				void setLiveapiRequestFrom(const std::string& liveapiRequestFrom);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string liveapiRequestFrom_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_

live/include/alibabacloud/live/model/DescribeLivePullStreamConfigResult.h → live/include/alibabacloud/live/model/DescribeLiveDomainLimitResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
-#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,32 +29,29 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_LIVE_EXPORT DescribeLivePullStreamConfigResult : public ServiceResult
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainLimitResult : public ServiceResult
 			{
 			public:
-				struct LiveAppRecord
+				struct LiveDomainLimit
 				{
-					std::string sourceUrl;
-					std::string streamName;
-					std::string endTime;
+					int limitTranscodeNum;
 					std::string domainName;
-					std::string startTime;
-					std::string appName;
+					int limitNum;
 				};
 
 
-				DescribeLivePullStreamConfigResult();
-				explicit DescribeLivePullStreamConfigResult(const std::string &payload);
-				~DescribeLivePullStreamConfigResult();
-				std::vector<LiveAppRecord> getLiveAppRecordList()const;
+				DescribeLiveDomainLimitResult();
+				explicit DescribeLiveDomainLimitResult(const std::string &payload);
+				~DescribeLiveDomainLimitResult();
+				std::vector<LiveDomainLimit> getLiveDomainLimitList()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<LiveAppRecord> liveAppRecordList_;
+				std::vector<LiveDomainLimit> liveDomainLimitList_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPULLSTREAMCONFIGRESULT_H_
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITRESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataRequest.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_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainTimeShiftDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveDomainTimeShiftDataRequest();
+				~DescribeLiveDomainTimeShiftDataRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				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);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				std::string startTime_;
+				std::string domainName_;
+				std::string endTime_;
+				long ownerId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATARESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATARESULT_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 DescribeLiveDomainTimeShiftDataResult : public ServiceResult
+			{
+			public:
+				struct DataModule
+				{
+					std::string type;
+					std::string size;
+					std::string timeStamp;
+				};
+
+
+				DescribeLiveDomainTimeShiftDataResult();
+				explicit DescribeLiveDomainTimeShiftDataResult(const std::string &payload);
+				~DescribeLiveDomainTimeShiftDataResult();
+				std::vector<DataModule> getTimeShiftData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DataModule> timeShiftData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATARESULT_H_

live/include/alibabacloud/live/model/DescribeLiveSnapshotConfigResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string overwriteOssObject;
 					std::string sequenceOssObject;
+					std::string callback;
 					int timeInterval;
 					std::string ossEndpoint;
 					std::string domainName;

live/include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoResult.h

@@ -36,14 +36,16 @@ namespace AlibabaCloud
 				{
 					struct CustomTranscodeParameters
 					{
-						int audioBitrate;
 						int fPS;
-						std::string audioProfile;
 						std::string gop;
+						std::string templateType;
+						int audioBitrate;
+						std::string bframes;
+						std::string audioProfile;
+						std::string rtsFlag;
 						int height;
 						std::string videoProfile;
 						int audioChannelNum;
-						std::string templateType;
 						int width;
 						std::string audioCodec;
 						int audioRate;

live/include/alibabacloud/live/model/UnTagLiveResourcesRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				UnTagLiveResourcesRequest();
 				~UnTagLiveResourcesRequest();
 
+				bool getAll()const;
+				void setAll(bool all);
 				std::vector<std::string> getResourceId()const;
 				void setResourceId(const std::vector<std::string>& resourceId);
 				long getOwnerId()const;
@@ -45,6 +47,7 @@ namespace AlibabaCloud
 				void setTagKey(const std::vector<std::string>& tagKey);
 
             private:
+				bool all_;
 				std::vector<std::string> resourceId_;
 				long ownerId_;
 				std::string resourceType_;

live/include/alibabacloud/live/model/UpdateLiveAppSnapshotConfigRequest.h

@@ -53,6 +53,8 @@ namespace AlibabaCloud
 				void setSequenceOssObject(const std::string& sequenceOssObject);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getCallback()const;
+				void setCallback(const std::string& callback);
 
             private:
 				int timeInterval_;
@@ -64,6 +66,7 @@ namespace AlibabaCloud
 				std::string domainName_;
 				std::string sequenceOssObject_;
 				long ownerId_;
+				std::string callback_;
 
 			};
 		}

live/src/LiveClient.cc

@@ -31,21 +31,21 @@ LiveClient::LiveClient(const Credentials &credentials, const ClientConfiguration
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 LiveClient::LiveClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 LiveClient::LiveClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "live");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 LiveClient::~LiveClient()
@@ -771,6 +771,42 @@ LiveClient::AddLiveStreamTranscodeOutcomeCallable LiveClient::addLiveStreamTrans
 	return task->get_future();
 }
 
+LiveClient::AddRtsLiveStreamTranscodeOutcome LiveClient::addRtsLiveStreamTranscode(const AddRtsLiveStreamTranscodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddRtsLiveStreamTranscodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddRtsLiveStreamTranscodeOutcome(AddRtsLiveStreamTranscodeResult(outcome.result()));
+	else
+		return AddRtsLiveStreamTranscodeOutcome(outcome.error());
+}
+
+void LiveClient::addRtsLiveStreamTranscodeAsync(const AddRtsLiveStreamTranscodeRequest& request, const AddRtsLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addRtsLiveStreamTranscode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::AddRtsLiveStreamTranscodeOutcomeCallable LiveClient::addRtsLiveStreamTranscodeCallable(const AddRtsLiveStreamTranscodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddRtsLiveStreamTranscodeOutcome()>>(
+			[this, request]()
+			{
+			return this->addRtsLiveStreamTranscode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::AddTrancodeSEIOutcome LiveClient::addTrancodeSEI(const AddTrancodeSEIRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3255,6 +3291,42 @@ LiveClient::DescribeLiveDomainBpsDataByTimeStampOutcomeCallable LiveClient::desc
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainCertificateInfoOutcome LiveClient::describeLiveDomainCertificateInfo(const DescribeLiveDomainCertificateInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainCertificateInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainCertificateInfoOutcome(DescribeLiveDomainCertificateInfoResult(outcome.result()));
+	else
+		return DescribeLiveDomainCertificateInfoOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainCertificateInfoAsync(const DescribeLiveDomainCertificateInfoRequest& request, const DescribeLiveDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainCertificateInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainCertificateInfoOutcomeCallable LiveClient::describeLiveDomainCertificateInfoCallable(const DescribeLiveDomainCertificateInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainCertificateInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainCertificateInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainConfigsOutcome LiveClient::describeLiveDomainConfigs(const DescribeLiveDomainConfigsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3363,6 +3435,42 @@ LiveClient::DescribeLiveDomainFrameRateAndBitRateDataOutcomeCallable LiveClient:
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDomainLimitOutcome LiveClient::describeLiveDomainLimit(const DescribeLiveDomainLimitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDomainLimitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDomainLimitOutcome(DescribeLiveDomainLimitResult(outcome.result()));
+	else
+		return DescribeLiveDomainLimitOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDomainLimitAsync(const DescribeLiveDomainLimitRequest& request, const DescribeLiveDomainLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDomainLimit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDomainLimitOutcomeCallable LiveClient::describeLiveDomainLimitCallable(const DescribeLiveDomainLimitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainLimitOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDomainLimit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDomainMappingOutcome LiveClient::describeLiveDomainMapping(const DescribeLiveDomainMappingRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3723,144 +3831,144 @@ LiveClient::DescribeLiveDomainSnapshotDataOutcomeCallable LiveClient::describeLi
 	return task->get_future();
 }
 
-LiveClient::DescribeLiveDomainTrafficDataOutcome LiveClient::describeLiveDomainTrafficData(const DescribeLiveDomainTrafficDataRequest &request) const
+LiveClient::DescribeLiveDomainTimeShiftDataOutcome LiveClient::describeLiveDomainTimeShiftData(const DescribeLiveDomainTimeShiftDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeLiveDomainTrafficDataOutcome(endpointOutcome.error());
+		return DescribeLiveDomainTimeShiftDataOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeLiveDomainTrafficDataOutcome(DescribeLiveDomainTrafficDataResult(outcome.result()));
+		return DescribeLiveDomainTimeShiftDataOutcome(DescribeLiveDomainTimeShiftDataResult(outcome.result()));
 	else
-		return DescribeLiveDomainTrafficDataOutcome(outcome.error());
+		return DescribeLiveDomainTimeShiftDataOutcome(outcome.error());
 }
 
-void LiveClient::describeLiveDomainTrafficDataAsync(const DescribeLiveDomainTrafficDataRequest& request, const DescribeLiveDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void LiveClient::describeLiveDomainTimeShiftDataAsync(const DescribeLiveDomainTimeShiftDataRequest& request, const DescribeLiveDomainTimeShiftDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeLiveDomainTrafficData(request), context);
+		handler(this, request, describeLiveDomainTimeShiftData(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-LiveClient::DescribeLiveDomainTrafficDataOutcomeCallable LiveClient::describeLiveDomainTrafficDataCallable(const DescribeLiveDomainTrafficDataRequest &request) const
+LiveClient::DescribeLiveDomainTimeShiftDataOutcomeCallable LiveClient::describeLiveDomainTimeShiftDataCallable(const DescribeLiveDomainTimeShiftDataRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTrafficDataOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTimeShiftDataOutcome()>>(
 			[this, request]()
 			{
-			return this->describeLiveDomainTrafficData(request);
+			return this->describeLiveDomainTimeShiftData(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-LiveClient::DescribeLiveDomainTranscodeDataOutcome LiveClient::describeLiveDomainTranscodeData(const DescribeLiveDomainTranscodeDataRequest &request) const
+LiveClient::DescribeLiveDomainTrafficDataOutcome LiveClient::describeLiveDomainTrafficData(const DescribeLiveDomainTrafficDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeLiveDomainTranscodeDataOutcome(endpointOutcome.error());
+		return DescribeLiveDomainTrafficDataOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeLiveDomainTranscodeDataOutcome(DescribeLiveDomainTranscodeDataResult(outcome.result()));
+		return DescribeLiveDomainTrafficDataOutcome(DescribeLiveDomainTrafficDataResult(outcome.result()));
 	else
-		return DescribeLiveDomainTranscodeDataOutcome(outcome.error());
+		return DescribeLiveDomainTrafficDataOutcome(outcome.error());
 }
 
-void LiveClient::describeLiveDomainTranscodeDataAsync(const DescribeLiveDomainTranscodeDataRequest& request, const DescribeLiveDomainTranscodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void LiveClient::describeLiveDomainTrafficDataAsync(const DescribeLiveDomainTrafficDataRequest& request, const DescribeLiveDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeLiveDomainTranscodeData(request), context);
+		handler(this, request, describeLiveDomainTrafficData(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-LiveClient::DescribeLiveDomainTranscodeDataOutcomeCallable LiveClient::describeLiveDomainTranscodeDataCallable(const DescribeLiveDomainTranscodeDataRequest &request) const
+LiveClient::DescribeLiveDomainTrafficDataOutcomeCallable LiveClient::describeLiveDomainTrafficDataCallable(const DescribeLiveDomainTrafficDataRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTranscodeDataOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTrafficDataOutcome()>>(
 			[this, request]()
 			{
-			return this->describeLiveDomainTranscodeData(request);
+			return this->describeLiveDomainTrafficData(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-LiveClient::DescribeLiveLazyPullStreamConfigOutcome LiveClient::describeLiveLazyPullStreamConfig(const DescribeLiveLazyPullStreamConfigRequest &request) const
+LiveClient::DescribeLiveDomainTranscodeDataOutcome LiveClient::describeLiveDomainTranscodeData(const DescribeLiveDomainTranscodeDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeLiveLazyPullStreamConfigOutcome(endpointOutcome.error());
+		return DescribeLiveDomainTranscodeDataOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeLiveLazyPullStreamConfigOutcome(DescribeLiveLazyPullStreamConfigResult(outcome.result()));
+		return DescribeLiveDomainTranscodeDataOutcome(DescribeLiveDomainTranscodeDataResult(outcome.result()));
 	else
-		return DescribeLiveLazyPullStreamConfigOutcome(outcome.error());
+		return DescribeLiveDomainTranscodeDataOutcome(outcome.error());
 }
 
-void LiveClient::describeLiveLazyPullStreamConfigAsync(const DescribeLiveLazyPullStreamConfigRequest& request, const DescribeLiveLazyPullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void LiveClient::describeLiveDomainTranscodeDataAsync(const DescribeLiveDomainTranscodeDataRequest& request, const DescribeLiveDomainTranscodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeLiveLazyPullStreamConfig(request), context);
+		handler(this, request, describeLiveDomainTranscodeData(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-LiveClient::DescribeLiveLazyPullStreamConfigOutcomeCallable LiveClient::describeLiveLazyPullStreamConfigCallable(const DescribeLiveLazyPullStreamConfigRequest &request) const
+LiveClient::DescribeLiveDomainTranscodeDataOutcomeCallable LiveClient::describeLiveDomainTranscodeDataCallable(const DescribeLiveDomainTranscodeDataRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeLiveLazyPullStreamConfigOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDomainTranscodeDataOutcome()>>(
 			[this, request]()
 			{
-			return this->describeLiveLazyPullStreamConfig(request);
+			return this->describeLiveDomainTranscodeData(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-LiveClient::DescribeLivePullStreamConfigOutcome LiveClient::describeLivePullStreamConfig(const DescribeLivePullStreamConfigRequest &request) const
+LiveClient::DescribeLiveLazyPullStreamConfigOutcome LiveClient::describeLiveLazyPullStreamConfig(const DescribeLiveLazyPullStreamConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeLivePullStreamConfigOutcome(endpointOutcome.error());
+		return DescribeLiveLazyPullStreamConfigOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeLivePullStreamConfigOutcome(DescribeLivePullStreamConfigResult(outcome.result()));
+		return DescribeLiveLazyPullStreamConfigOutcome(DescribeLiveLazyPullStreamConfigResult(outcome.result()));
 	else
-		return DescribeLivePullStreamConfigOutcome(outcome.error());
+		return DescribeLiveLazyPullStreamConfigOutcome(outcome.error());
 }
 
-void LiveClient::describeLivePullStreamConfigAsync(const DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void LiveClient::describeLiveLazyPullStreamConfigAsync(const DescribeLiveLazyPullStreamConfigRequest& request, const DescribeLiveLazyPullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeLivePullStreamConfig(request), context);
+		handler(this, request, describeLiveLazyPullStreamConfig(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-LiveClient::DescribeLivePullStreamConfigOutcomeCallable LiveClient::describeLivePullStreamConfigCallable(const DescribeLivePullStreamConfigRequest &request) const
+LiveClient::DescribeLiveLazyPullStreamConfigOutcomeCallable LiveClient::describeLiveLazyPullStreamConfigCallable(const DescribeLiveLazyPullStreamConfigRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeLivePullStreamConfigOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DescribeLiveLazyPullStreamConfigOutcome()>>(
 			[this, request]()
 			{
-			return this->describeLivePullStreamConfig(request);
+			return this->describeLiveLazyPullStreamConfig(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

live/src/model/AddLiveAppSnapshotConfigRequest.cc

@@ -126,3 +126,14 @@ void AddLiveAppSnapshotConfigRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string AddLiveAppSnapshotConfigRequest::getCallback()const
+{
+	return callback_;
+}
+
+void AddLiveAppSnapshotConfigRequest::setCallback(const std::string& callback)
+{
+	callback_ = callback;
+	setParameter("Callback", callback);
+}
+

live/src/model/AddLivePullStreamInfoConfigRequest.cc

@@ -60,6 +60,17 @@ void AddLivePullStreamInfoConfigRequest::setStreamName(const std::string& stream
 	setParameter("StreamName", streamName);
 }
 
+std::string AddLivePullStreamInfoConfigRequest::getPullAlways()const
+{
+	return pullAlways_;
+}
+
+void AddLivePullStreamInfoConfigRequest::setPullAlways(const std::string& pullAlways)
+{
+	pullAlways_ = pullAlways;
+	setParameter("PullAlways", pullAlways);
+}
+
 std::string AddLivePullStreamInfoConfigRequest::getDomainName()const
 {
 	return domainName_;

live/src/model/AddRtsLiveStreamTranscodeRequest.cc

@@ -0,0 +1,227 @@
+/*
+ * 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/AddRtsLiveStreamTranscodeRequest.h>
+
+using AlibabaCloud::Live::Model::AddRtsLiveStreamTranscodeRequest;
+
+AddRtsLiveStreamTranscodeRequest::AddRtsLiveStreamTranscodeRequest() :
+	RpcServiceRequest("live", "2016-11-01", "AddRtsLiveStreamTranscode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddRtsLiveStreamTranscodeRequest::~AddRtsLiveStreamTranscodeRequest()
+{}
+
+std::string AddRtsLiveStreamTranscodeRequest::get_Template()const
+{
+	return _template_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::set_Template(const std::string& _template)
+{
+	_template_ = _template;
+	setParameter("_Template", _template);
+}
+
+bool AddRtsLiveStreamTranscodeRequest::getDeleteBframes()const
+{
+	return deleteBframes_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setDeleteBframes(bool deleteBframes)
+{
+	deleteBframes_ = deleteBframes;
+	setParameter("DeleteBframes", deleteBframes ? "true" : "false");
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getGop()const
+{
+	return gop_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setGop(const std::string& gop)
+{
+	gop_ = gop;
+	setParameter("Gop", gop);
+}
+
+bool AddRtsLiveStreamTranscodeRequest::getOpus()const
+{
+	return opus_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setOpus(bool opus)
+{
+	opus_ = opus;
+	setParameter("Opus", opus ? "true" : "false");
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getAudioCodec()const
+{
+	return audioCodec_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioCodec(const std::string& audioCodec)
+{
+	audioCodec_ = audioCodec;
+	setParameter("AudioCodec", audioCodec);
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getTemplateType()const
+{
+	return templateType_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setTemplateType(const std::string& templateType)
+{
+	templateType_ = templateType;
+	setParameter("TemplateType", templateType);
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getAudioProfile()const
+{
+	return audioProfile_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioProfile(const std::string& audioProfile)
+{
+	audioProfile_ = audioProfile;
+	setParameter("AudioProfile", audioProfile);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getHeight()const
+{
+	return height_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setHeight(int height)
+{
+	height_ = height;
+	setParameter("Height", std::to_string(height));
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getApp()const
+{
+	return app_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setApp(const std::string& app)
+{
+	app_ = app;
+	setParameter("App", app);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioChannelNum()const
+{
+	return audioChannelNum_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioChannelNum(int audioChannelNum)
+{
+	audioChannelNum_ = audioChannelNum;
+	setParameter("AudioChannelNum", std::to_string(audioChannelNum));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getProfile()const
+{
+	return profile_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setProfile(int profile)
+{
+	profile_ = profile;
+	setParameter("Profile", std::to_string(profile));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getFPS()const
+{
+	return fPS_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setFPS(int fPS)
+{
+	fPS_ = fPS;
+	setParameter("FPS", std::to_string(fPS));
+}
+
+long AddRtsLiveStreamTranscodeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioRate()const
+{
+	return audioRate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioRate(int audioRate)
+{
+	audioRate_ = audioRate;
+	setParameter("AudioRate", std::to_string(audioRate));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioBitrate()const
+{
+	return audioBitrate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioBitrate(int audioBitrate)
+{
+	audioBitrate_ = audioBitrate;
+	setParameter("AudioBitrate", std::to_string(audioBitrate));
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getDomain()const
+{
+	return domain_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setDomain(const std::string& domain)
+{
+	domain_ = domain;
+	setParameter("Domain", domain);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getWidth()const
+{
+	return width_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setWidth(int width)
+{
+	width_ = width;
+	setParameter("Width", std::to_string(width));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getVideoBitrate()const
+{
+	return videoBitrate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setVideoBitrate(int videoBitrate)
+{
+	videoBitrate_ = videoBitrate;
+	setParameter("VideoBitrate", std::to_string(videoBitrate));
+}
+

live/src/model/AddRtsLiveStreamTranscodeResult.cc

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

live/src/model/DescribeLiveDomainCertificateInfoRequest.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/DescribeLiveDomainCertificateInfoRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainCertificateInfoRequest;
+
+DescribeLiveDomainCertificateInfoRequest::DescribeLiveDomainCertificateInfoRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainCertificateInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainCertificateInfoRequest::~DescribeLiveDomainCertificateInfoRequest()
+{}
+
+std::string DescribeLiveDomainCertificateInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeLiveDomainCertificateInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeLiveDomainCertificateInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveDomainCertificateInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveDomainCertificateInfoResult.cc

@@ -0,0 +1,75 @@
+/*
+ * 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/DescribeLiveDomainCertificateInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainCertificateInfoResult::DescribeLiveDomainCertificateInfoResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainCertificateInfoResult::DescribeLiveDomainCertificateInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainCertificateInfoResult::~DescribeLiveDomainCertificateInfoResult()
+{}
+
+void DescribeLiveDomainCertificateInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCertInfosNode = value["CertInfos"]["CertInfo"];
+	for (auto valueCertInfosCertInfo : allCertInfosNode)
+	{
+		CertInfo certInfosObject;
+		if(!valueCertInfosCertInfo["DomainName"].isNull())
+			certInfosObject.domainName = valueCertInfosCertInfo["DomainName"].asString();
+		if(!valueCertInfosCertInfo["CertName"].isNull())
+			certInfosObject.certName = valueCertInfosCertInfo["CertName"].asString();
+		if(!valueCertInfosCertInfo["CertDomainName"].isNull())
+			certInfosObject.certDomainName = valueCertInfosCertInfo["CertDomainName"].asString();
+		if(!valueCertInfosCertInfo["CertExpireTime"].isNull())
+			certInfosObject.certExpireTime = valueCertInfosCertInfo["CertExpireTime"].asString();
+		if(!valueCertInfosCertInfo["CertLife"].isNull())
+			certInfosObject.certLife = valueCertInfosCertInfo["CertLife"].asString();
+		if(!valueCertInfosCertInfo["CertOrg"].isNull())
+			certInfosObject.certOrg = valueCertInfosCertInfo["CertOrg"].asString();
+		if(!valueCertInfosCertInfo["CertType"].isNull())
+			certInfosObject.certType = valueCertInfosCertInfo["CertType"].asString();
+		if(!valueCertInfosCertInfo["SSLProtocol"].isNull())
+			certInfosObject.sSLProtocol = valueCertInfosCertInfo["SSLProtocol"].asString();
+		if(!valueCertInfosCertInfo["Status"].isNull())
+			certInfosObject.status = valueCertInfosCertInfo["Status"].asString();
+		if(!valueCertInfosCertInfo["SSLPub"].isNull())
+			certInfosObject.sSLPub = valueCertInfosCertInfo["SSLPub"].asString();
+		certInfos_.push_back(certInfosObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainCertificateInfoResult::CertInfo> DescribeLiveDomainCertificateInfoResult::getCertInfos()const
+{
+	return certInfos_;
+}
+

live/src/model/DescribeLiveDomainLimitRequest.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/DescribeLiveDomainLimitRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDomainLimitRequest;
+
+DescribeLiveDomainLimitRequest::DescribeLiveDomainLimitRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveDomainLimit")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDomainLimitRequest::~DescribeLiveDomainLimitRequest()
+{}
+
+std::string DescribeLiveDomainLimitRequest::getLiveapiRequestFrom()const
+{
+	return liveapiRequestFrom_;
+}
+
+void DescribeLiveDomainLimitRequest::setLiveapiRequestFrom(const std::string& liveapiRequestFrom)
+{
+	liveapiRequestFrom_ = liveapiRequestFrom;
+	setParameter("LiveapiRequestFrom", liveapiRequestFrom);
+}
+
+std::string DescribeLiveDomainLimitRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeLiveDomainLimitRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeLiveDomainLimitRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveDomainLimitRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveDomainLimitResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDomainLimitResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainLimitResult::DescribeLiveDomainLimitResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainLimitResult::DescribeLiveDomainLimitResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainLimitResult::~DescribeLiveDomainLimitResult()
+{}
+
+void DescribeLiveDomainLimitResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLiveDomainLimitListNode = value["LiveDomainLimitList"]["LiveDomainLimit"];
+	for (auto valueLiveDomainLimitListLiveDomainLimit : allLiveDomainLimitListNode)
+	{
+		LiveDomainLimit liveDomainLimitListObject;
+		if(!valueLiveDomainLimitListLiveDomainLimit["DomainName"].isNull())
+			liveDomainLimitListObject.domainName = valueLiveDomainLimitListLiveDomainLimit["DomainName"].asString();
+		if(!valueLiveDomainLimitListLiveDomainLimit["LimitNum"].isNull())
+			liveDomainLimitListObject.limitNum = std::stoi(valueLiveDomainLimitListLiveDomainLimit["LimitNum"].asString());
+		if(!valueLiveDomainLimitListLiveDomainLimit["LimitTranscodeNum"].isNull())
+			liveDomainLimitListObject.limitTranscodeNum = std::stoi(valueLiveDomainLimitListLiveDomainLimit["LimitTranscodeNum"].asString());
+		liveDomainLimitList_.push_back(liveDomainLimitListObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainLimitResult::LiveDomainLimit> DescribeLiveDomainLimitResult::getLiveDomainLimitList()const
+{
+	return liveDomainLimitList_;
+}
+

live/src/model/DescribeLiveDomainTimeShiftDataRequest.cc

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

live/src/model/DescribeLiveDomainTimeShiftDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainTimeShiftDataResult::DescribeLiveDomainTimeShiftDataResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainTimeShiftDataResult::DescribeLiveDomainTimeShiftDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainTimeShiftDataResult::~DescribeLiveDomainTimeShiftDataResult()
+{}
+
+void DescribeLiveDomainTimeShiftDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTimeShiftDataNode = value["TimeShiftData"]["DataModule"];
+	for (auto valueTimeShiftDataDataModule : allTimeShiftDataNode)
+	{
+		DataModule timeShiftDataObject;
+		if(!valueTimeShiftDataDataModule["TimeStamp"].isNull())
+			timeShiftDataObject.timeStamp = valueTimeShiftDataDataModule["TimeStamp"].asString();
+		if(!valueTimeShiftDataDataModule["Size"].isNull())
+			timeShiftDataObject.size = valueTimeShiftDataDataModule["Size"].asString();
+		if(!valueTimeShiftDataDataModule["Type"].isNull())
+			timeShiftDataObject.type = valueTimeShiftDataDataModule["Type"].asString();
+		timeShiftData_.push_back(timeShiftDataObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainTimeShiftDataResult::DataModule> DescribeLiveDomainTimeShiftDataResult::getTimeShiftData()const
+{
+	return timeShiftData_;
+}
+

live/src/model/DescribeLivePullStreamConfigRequest.cc

@@ -1,62 +0,0 @@
-/*
- * 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/DescribeLivePullStreamConfigRequest.h>
-
-using AlibabaCloud::Live::Model::DescribeLivePullStreamConfigRequest;
-
-DescribeLivePullStreamConfigRequest::DescribeLivePullStreamConfigRequest() :
-	RpcServiceRequest("live", "2016-11-01", "DescribeLivePullStreamConfig")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeLivePullStreamConfigRequest::~DescribeLivePullStreamConfigRequest()
-{}
-
-std::string DescribeLivePullStreamConfigRequest::getDomainName()const
-{
-	return domainName_;
-}
-
-void DescribeLivePullStreamConfigRequest::setDomainName(const std::string& domainName)
-{
-	domainName_ = domainName;
-	setParameter("DomainName", domainName);
-}
-
-long DescribeLivePullStreamConfigRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DescribeLivePullStreamConfigRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string DescribeLivePullStreamConfigRequest::getSecurityToken()const
-{
-	return securityToken_;
-}
-
-void DescribeLivePullStreamConfigRequest::setSecurityToken(const std::string& securityToken)
-{
-	securityToken_ = securityToken;
-	setParameter("SecurityToken", securityToken);
-}
-

live/src/model/DescribeLivePullStreamConfigResult.cc

@@ -1,67 +0,0 @@
-/*
- * 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/DescribeLivePullStreamConfigResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Live;
-using namespace AlibabaCloud::Live::Model;
-
-DescribeLivePullStreamConfigResult::DescribeLivePullStreamConfigResult() :
-	ServiceResult()
-{}
-
-DescribeLivePullStreamConfigResult::DescribeLivePullStreamConfigResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeLivePullStreamConfigResult::~DescribeLivePullStreamConfigResult()
-{}
-
-void DescribeLivePullStreamConfigResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allLiveAppRecordListNode = value["LiveAppRecordList"]["LiveAppRecord"];
-	for (auto valueLiveAppRecordListLiveAppRecord : allLiveAppRecordListNode)
-	{
-		LiveAppRecord liveAppRecordListObject;
-		if(!valueLiveAppRecordListLiveAppRecord["DomainName"].isNull())
-			liveAppRecordListObject.domainName = valueLiveAppRecordListLiveAppRecord["DomainName"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["AppName"].isNull())
-			liveAppRecordListObject.appName = valueLiveAppRecordListLiveAppRecord["AppName"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["StreamName"].isNull())
-			liveAppRecordListObject.streamName = valueLiveAppRecordListLiveAppRecord["StreamName"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["SourceUrl"].isNull())
-			liveAppRecordListObject.sourceUrl = valueLiveAppRecordListLiveAppRecord["SourceUrl"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["StartTime"].isNull())
-			liveAppRecordListObject.startTime = valueLiveAppRecordListLiveAppRecord["StartTime"].asString();
-		if(!valueLiveAppRecordListLiveAppRecord["EndTime"].isNull())
-			liveAppRecordListObject.endTime = valueLiveAppRecordListLiveAppRecord["EndTime"].asString();
-		liveAppRecordList_.push_back(liveAppRecordListObject);
-	}
-
-}
-
-std::vector<DescribeLivePullStreamConfigResult::LiveAppRecord> DescribeLivePullStreamConfigResult::getLiveAppRecordList()const
-{
-	return liveAppRecordList_;
-}
-

live/src/model/DescribeLiveSnapshotConfigResult.cc

@@ -59,6 +59,8 @@ void DescribeLiveSnapshotConfigResult::parse(const std::string &payload)
 			liveStreamSnapshotConfigListObject.sequenceOssObject = valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["SequenceOssObject"].asString();
 		if(!valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["CreateTime"].isNull())
 			liveStreamSnapshotConfigListObject.createTime = valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["CreateTime"].asString();
+		if(!valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["Callback"].isNull())
+			liveStreamSnapshotConfigListObject.callback = valueLiveStreamSnapshotConfigListLiveStreamSnapshotConfig["Callback"].asString();
 		liveStreamSnapshotConfigList_.push_back(liveStreamSnapshotConfigListObject);
 	}
 	if(!value["PageNum"].isNull())

live/src/model/DescribeLiveStreamTranscodeInfoResult.cc

@@ -50,6 +50,10 @@ void DescribeLiveStreamTranscodeInfoResult::parse(const std::string &payload)
 		if(!valueDomainTranscodeListDomainTranscodeInfo["TranscodeTemplate"].isNull())
 			domainTranscodeListObject.transcodeTemplate = valueDomainTranscodeListDomainTranscodeInfo["TranscodeTemplate"].asString();
 		auto customTranscodeParametersNode = value["CustomTranscodeParameters"];
+		if(!customTranscodeParametersNode["RtsFlag"].isNull())
+			domainTranscodeListObject.customTranscodeParameters.rtsFlag = customTranscodeParametersNode["RtsFlag"].asString();
+		if(!customTranscodeParametersNode["Bframes"].isNull())
+			domainTranscodeListObject.customTranscodeParameters.bframes = customTranscodeParametersNode["Bframes"].asString();
 		if(!customTranscodeParametersNode["VideoBitrate"].isNull())
 			domainTranscodeListObject.customTranscodeParameters.videoBitrate = std::stoi(customTranscodeParametersNode["VideoBitrate"].asString());
 		if(!customTranscodeParametersNode["FPS"].isNull())

live/src/model/UnTagLiveResourcesRequest.cc

@@ -27,6 +27,17 @@ UnTagLiveResourcesRequest::UnTagLiveResourcesRequest() :
 UnTagLiveResourcesRequest::~UnTagLiveResourcesRequest()
 {}
 
+bool UnTagLiveResourcesRequest::getAll()const
+{
+	return all_;
+}
+
+void UnTagLiveResourcesRequest::setAll(bool all)
+{
+	all_ = all;
+	setParameter("All", all ? "true" : "false");
+}
+
 std::vector<std::string> UnTagLiveResourcesRequest::getResourceId()const
 {
 	return resourceId_;

live/src/model/UpdateLiveAppSnapshotConfigRequest.cc

@@ -126,3 +126,14 @@ void UpdateLiveAppSnapshotConfigRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string UpdateLiveAppSnapshotConfigRequest::getCallback()const
+{
+	return callback_;
+}
+
+void UpdateLiveAppSnapshotConfigRequest::setCallback(const std::string& callback)
+{
+	callback_ = callback;
+	setParameter("Callback", callback);
+}
+