Generated 2016-11-01 for live.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-09-16 Version: 1.36.877
+- Generated 2016-11-01 for `live`.
+
 2021-09-15 Version: 1.36.876
 - Update AddFace SearchFace.
 

VERSION

@@ -1 +1 @@
-1.36.876
+1.36.877

live/CMakeLists.txt

@@ -105,6 +105,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/CreateBoardResult.h
 	include/alibabacloud/live/model/CreateCasterRequest.h
 	include/alibabacloud/live/model/CreateCasterResult.h
+	include/alibabacloud/live/model/CreateCustomTemplateRequest.h
+	include/alibabacloud/live/model/CreateCustomTemplateResult.h
 	include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryRequest.h
 	include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryResult.h
 	include/alibabacloud/live/model/CreateLiveStreamRecordIndexFilesRequest.h
@@ -131,6 +133,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DeleteCasterSceneConfigResult.h
 	include/alibabacloud/live/model/DeleteCasterVideoResourceRequest.h
 	include/alibabacloud/live/model/DeleteCasterVideoResourceResult.h
+	include/alibabacloud/live/model/DeleteCustomTemplateRequest.h
+	include/alibabacloud/live/model/DeleteCustomTemplateResult.h
 	include/alibabacloud/live/model/DeleteHtmlResourceRequest.h
 	include/alibabacloud/live/model/DeleteHtmlResourceResult.h
 	include/alibabacloud/live/model/DeleteLiveASRConfigRequest.h
@@ -151,6 +155,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DeleteLiveDomainMappingResult.h
 	include/alibabacloud/live/model/DeleteLiveDomainPlayMappingRequest.h
 	include/alibabacloud/live/model/DeleteLiveDomainPlayMappingResult.h
+	include/alibabacloud/live/model/DeleteLiveEdgeTransferRequest.h
+	include/alibabacloud/live/model/DeleteLiveEdgeTransferResult.h
 	include/alibabacloud/live/model/DeleteLiveLazyPullStreamInfoConfigRequest.h
 	include/alibabacloud/live/model/DeleteLiveLazyPullStreamInfoConfigResult.h
 	include/alibabacloud/live/model/DeleteLivePullStreamInfoConfigRequest.h
@@ -287,6 +293,10 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveDomainTranscodeDataResult.h
 	include/alibabacloud/live/model/DescribeLiveDrmUsageDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveDrmUsageDataResult.h
+	include/alibabacloud/live/model/DescribeLiveEdgeTransferRequest.h
+	include/alibabacloud/live/model/DescribeLiveEdgeTransferResult.h
+	include/alibabacloud/live/model/DescribeLiveIpInfoRequest.h
+	include/alibabacloud/live/model/DescribeLiveIpInfoResult.h
 	include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigRequest.h
 	include/alibabacloud/live/model/DescribeLiveLazyPullStreamConfigResult.h
 	include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h
@@ -327,6 +337,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveStreamRecordIndexFilesResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamSnapshotInfoRequest.h
 	include/alibabacloud/live/model/DescribeLiveStreamSnapshotInfoResult.h
+	include/alibabacloud/live/model/DescribeLiveStreamStateRequest.h
+	include/alibabacloud/live/model/DescribeLiveStreamStateResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoRequest.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeInfoResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamTranscodeStreamNumRequest.h
@@ -387,10 +399,14 @@ set(live_public_header_model
 	include/alibabacloud/live/model/EffectCasterVideoResourceResult.h
 	include/alibabacloud/live/model/EnableLiveRealtimeLogDeliveryRequest.h
 	include/alibabacloud/live/model/EnableLiveRealtimeLogDeliveryResult.h
+	include/alibabacloud/live/model/ForbidLiveCustomStreamRequest.h
+	include/alibabacloud/live/model/ForbidLiveCustomStreamResult.h
 	include/alibabacloud/live/model/ForbidLiveStreamRequest.h
 	include/alibabacloud/live/model/ForbidLiveStreamResult.h
 	include/alibabacloud/live/model/ForbidPushStreamRequest.h
 	include/alibabacloud/live/model/ForbidPushStreamResult.h
+	include/alibabacloud/live/model/GetCustomTemplateRequest.h
+	include/alibabacloud/live/model/GetCustomTemplateResult.h
 	include/alibabacloud/live/model/GetMultiRateConfigRequest.h
 	include/alibabacloud/live/model/GetMultiRateConfigResult.h
 	include/alibabacloud/live/model/GetMultiRateConfigListRequest.h
@@ -453,6 +469,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/SetLiveDomainCertificateResult.h
 	include/alibabacloud/live/model/SetLiveDomainStagingConfigRequest.h
 	include/alibabacloud/live/model/SetLiveDomainStagingConfigResult.h
+	include/alibabacloud/live/model/SetLiveEdgeTransferRequest.h
+	include/alibabacloud/live/model/SetLiveEdgeTransferResult.h
 	include/alibabacloud/live/model/SetLiveLazyPullStreamInfoConfigRequest.h
 	include/alibabacloud/live/model/SetLiveLazyPullStreamInfoConfigResult.h
 	include/alibabacloud/live/model/SetLiveStreamDelayConfigRequest.h
@@ -604,6 +622,8 @@ set(live_src
 	src/model/CreateBoardResult.cc
 	src/model/CreateCasterRequest.cc
 	src/model/CreateCasterResult.cc
+	src/model/CreateCustomTemplateRequest.cc
+	src/model/CreateCustomTemplateResult.cc
 	src/model/CreateLiveRealTimeLogDeliveryRequest.cc
 	src/model/CreateLiveRealTimeLogDeliveryResult.cc
 	src/model/CreateLiveStreamRecordIndexFilesRequest.cc
@@ -630,6 +650,8 @@ set(live_src
 	src/model/DeleteCasterSceneConfigResult.cc
 	src/model/DeleteCasterVideoResourceRequest.cc
 	src/model/DeleteCasterVideoResourceResult.cc
+	src/model/DeleteCustomTemplateRequest.cc
+	src/model/DeleteCustomTemplateResult.cc
 	src/model/DeleteHtmlResourceRequest.cc
 	src/model/DeleteHtmlResourceResult.cc
 	src/model/DeleteLiveASRConfigRequest.cc
@@ -650,6 +672,8 @@ set(live_src
 	src/model/DeleteLiveDomainMappingResult.cc
 	src/model/DeleteLiveDomainPlayMappingRequest.cc
 	src/model/DeleteLiveDomainPlayMappingResult.cc
+	src/model/DeleteLiveEdgeTransferRequest.cc
+	src/model/DeleteLiveEdgeTransferResult.cc
 	src/model/DeleteLiveLazyPullStreamInfoConfigRequest.cc
 	src/model/DeleteLiveLazyPullStreamInfoConfigResult.cc
 	src/model/DeleteLivePullStreamInfoConfigRequest.cc
@@ -786,6 +810,10 @@ set(live_src
 	src/model/DescribeLiveDomainTranscodeDataResult.cc
 	src/model/DescribeLiveDrmUsageDataRequest.cc
 	src/model/DescribeLiveDrmUsageDataResult.cc
+	src/model/DescribeLiveEdgeTransferRequest.cc
+	src/model/DescribeLiveEdgeTransferResult.cc
+	src/model/DescribeLiveIpInfoRequest.cc
+	src/model/DescribeLiveIpInfoResult.cc
 	src/model/DescribeLiveLazyPullStreamConfigRequest.cc
 	src/model/DescribeLiveLazyPullStreamConfigResult.cc
 	src/model/DescribeLivePullStreamConfigRequest.cc
@@ -826,6 +854,8 @@ set(live_src
 	src/model/DescribeLiveStreamRecordIndexFilesResult.cc
 	src/model/DescribeLiveStreamSnapshotInfoRequest.cc
 	src/model/DescribeLiveStreamSnapshotInfoResult.cc
+	src/model/DescribeLiveStreamStateRequest.cc
+	src/model/DescribeLiveStreamStateResult.cc
 	src/model/DescribeLiveStreamTranscodeInfoRequest.cc
 	src/model/DescribeLiveStreamTranscodeInfoResult.cc
 	src/model/DescribeLiveStreamTranscodeStreamNumRequest.cc
@@ -886,10 +916,14 @@ set(live_src
 	src/model/EffectCasterVideoResourceResult.cc
 	src/model/EnableLiveRealtimeLogDeliveryRequest.cc
 	src/model/EnableLiveRealtimeLogDeliveryResult.cc
+	src/model/ForbidLiveCustomStreamRequest.cc
+	src/model/ForbidLiveCustomStreamResult.cc
 	src/model/ForbidLiveStreamRequest.cc
 	src/model/ForbidLiveStreamResult.cc
 	src/model/ForbidPushStreamRequest.cc
 	src/model/ForbidPushStreamResult.cc
+	src/model/GetCustomTemplateRequest.cc
+	src/model/GetCustomTemplateResult.cc
 	src/model/GetMultiRateConfigRequest.cc
 	src/model/GetMultiRateConfigResult.cc
 	src/model/GetMultiRateConfigListRequest.cc
@@ -952,6 +986,8 @@ set(live_src
 	src/model/SetLiveDomainCertificateResult.cc
 	src/model/SetLiveDomainStagingConfigRequest.cc
 	src/model/SetLiveDomainStagingConfigResult.cc
+	src/model/SetLiveEdgeTransferRequest.cc
+	src/model/SetLiveEdgeTransferResult.cc
 	src/model/SetLiveLazyPullStreamInfoConfigRequest.cc
 	src/model/SetLiveLazyPullStreamInfoConfigResult.cc
 	src/model/SetLiveStreamDelayConfigRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -106,6 +106,8 @@
 #include "model/CreateBoardResult.h"
 #include "model/CreateCasterRequest.h"
 #include "model/CreateCasterResult.h"
+#include "model/CreateCustomTemplateRequest.h"
+#include "model/CreateCustomTemplateResult.h"
 #include "model/CreateLiveRealTimeLogDeliveryRequest.h"
 #include "model/CreateLiveRealTimeLogDeliveryResult.h"
 #include "model/CreateLiveStreamRecordIndexFilesRequest.h"
@@ -132,6 +134,8 @@
 #include "model/DeleteCasterSceneConfigResult.h"
 #include "model/DeleteCasterVideoResourceRequest.h"
 #include "model/DeleteCasterVideoResourceResult.h"
+#include "model/DeleteCustomTemplateRequest.h"
+#include "model/DeleteCustomTemplateResult.h"
 #include "model/DeleteHtmlResourceRequest.h"
 #include "model/DeleteHtmlResourceResult.h"
 #include "model/DeleteLiveASRConfigRequest.h"
@@ -152,6 +156,8 @@
 #include "model/DeleteLiveDomainMappingResult.h"
 #include "model/DeleteLiveDomainPlayMappingRequest.h"
 #include "model/DeleteLiveDomainPlayMappingResult.h"
+#include "model/DeleteLiveEdgeTransferRequest.h"
+#include "model/DeleteLiveEdgeTransferResult.h"
 #include "model/DeleteLiveLazyPullStreamInfoConfigRequest.h"
 #include "model/DeleteLiveLazyPullStreamInfoConfigResult.h"
 #include "model/DeleteLivePullStreamInfoConfigRequest.h"
@@ -288,6 +294,10 @@
 #include "model/DescribeLiveDomainTranscodeDataResult.h"
 #include "model/DescribeLiveDrmUsageDataRequest.h"
 #include "model/DescribeLiveDrmUsageDataResult.h"
+#include "model/DescribeLiveEdgeTransferRequest.h"
+#include "model/DescribeLiveEdgeTransferResult.h"
+#include "model/DescribeLiveIpInfoRequest.h"
+#include "model/DescribeLiveIpInfoResult.h"
 #include "model/DescribeLiveLazyPullStreamConfigRequest.h"
 #include "model/DescribeLiveLazyPullStreamConfigResult.h"
 #include "model/DescribeLivePullStreamConfigRequest.h"
@@ -328,6 +338,8 @@
 #include "model/DescribeLiveStreamRecordIndexFilesResult.h"
 #include "model/DescribeLiveStreamSnapshotInfoRequest.h"
 #include "model/DescribeLiveStreamSnapshotInfoResult.h"
+#include "model/DescribeLiveStreamStateRequest.h"
+#include "model/DescribeLiveStreamStateResult.h"
 #include "model/DescribeLiveStreamTranscodeInfoRequest.h"
 #include "model/DescribeLiveStreamTranscodeInfoResult.h"
 #include "model/DescribeLiveStreamTranscodeStreamNumRequest.h"
@@ -388,10 +400,14 @@
 #include "model/EffectCasterVideoResourceResult.h"
 #include "model/EnableLiveRealtimeLogDeliveryRequest.h"
 #include "model/EnableLiveRealtimeLogDeliveryResult.h"
+#include "model/ForbidLiveCustomStreamRequest.h"
+#include "model/ForbidLiveCustomStreamResult.h"
 #include "model/ForbidLiveStreamRequest.h"
 #include "model/ForbidLiveStreamResult.h"
 #include "model/ForbidPushStreamRequest.h"
 #include "model/ForbidPushStreamResult.h"
+#include "model/GetCustomTemplateRequest.h"
+#include "model/GetCustomTemplateResult.h"
 #include "model/GetMultiRateConfigRequest.h"
 #include "model/GetMultiRateConfigResult.h"
 #include "model/GetMultiRateConfigListRequest.h"
@@ -454,6 +470,8 @@
 #include "model/SetLiveDomainCertificateResult.h"
 #include "model/SetLiveDomainStagingConfigRequest.h"
 #include "model/SetLiveDomainStagingConfigResult.h"
+#include "model/SetLiveEdgeTransferRequest.h"
+#include "model/SetLiveEdgeTransferResult.h"
 #include "model/SetLiveLazyPullStreamInfoConfigRequest.h"
 #include "model/SetLiveLazyPullStreamInfoConfigResult.h"
 #include "model/SetLiveStreamDelayConfigRequest.h"
@@ -653,6 +671,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateCasterResult> CreateCasterOutcome;
 			typedef std::future<CreateCasterOutcome> CreateCasterOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::CreateCasterRequest&, const CreateCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCasterAsyncHandler;
+			typedef Outcome<Error, Model::CreateCustomTemplateResult> CreateCustomTemplateOutcome;
+			typedef std::future<CreateCustomTemplateOutcome> CreateCustomTemplateOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::CreateCustomTemplateRequest&, const CreateCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCustomTemplateAsyncHandler;
 			typedef Outcome<Error, Model::CreateLiveRealTimeLogDeliveryResult> CreateLiveRealTimeLogDeliveryOutcome;
 			typedef std::future<CreateLiveRealTimeLogDeliveryOutcome> CreateLiveRealTimeLogDeliveryOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::CreateLiveRealTimeLogDeliveryRequest&, const CreateLiveRealTimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveRealTimeLogDeliveryAsyncHandler;
@@ -692,6 +713,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteCasterVideoResourceResult> DeleteCasterVideoResourceOutcome;
 			typedef std::future<DeleteCasterVideoResourceOutcome> DeleteCasterVideoResourceOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteCasterVideoResourceRequest&, const DeleteCasterVideoResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterVideoResourceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCustomTemplateResult> DeleteCustomTemplateOutcome;
+			typedef std::future<DeleteCustomTemplateOutcome> DeleteCustomTemplateOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DeleteCustomTemplateRequest&, const DeleteCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCustomTemplateAsyncHandler;
 			typedef Outcome<Error, Model::DeleteHtmlResourceResult> DeleteHtmlResourceOutcome;
 			typedef std::future<DeleteHtmlResourceOutcome> DeleteHtmlResourceOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteHtmlResourceRequest&, const DeleteHtmlResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHtmlResourceAsyncHandler;
@@ -722,6 +746,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteLiveDomainPlayMappingResult> DeleteLiveDomainPlayMappingOutcome;
 			typedef std::future<DeleteLiveDomainPlayMappingOutcome> DeleteLiveDomainPlayMappingOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteLiveDomainPlayMappingRequest&, const DeleteLiveDomainPlayMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDomainPlayMappingAsyncHandler;
+			typedef Outcome<Error, Model::DeleteLiveEdgeTransferResult> DeleteLiveEdgeTransferOutcome;
+			typedef std::future<DeleteLiveEdgeTransferOutcome> DeleteLiveEdgeTransferOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DeleteLiveEdgeTransferRequest&, const DeleteLiveEdgeTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveEdgeTransferAsyncHandler;
 			typedef Outcome<Error, Model::DeleteLiveLazyPullStreamInfoConfigResult> DeleteLiveLazyPullStreamInfoConfigOutcome;
 			typedef std::future<DeleteLiveLazyPullStreamInfoConfigOutcome> DeleteLiveLazyPullStreamInfoConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteLiveLazyPullStreamInfoConfigRequest&, const DeleteLiveLazyPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveLazyPullStreamInfoConfigAsyncHandler;
@@ -926,6 +953,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveDrmUsageDataResult> DescribeLiveDrmUsageDataOutcome;
 			typedef std::future<DescribeLiveDrmUsageDataOutcome> DescribeLiveDrmUsageDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDrmUsageDataRequest&, const DescribeLiveDrmUsageDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDrmUsageDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveEdgeTransferResult> DescribeLiveEdgeTransferOutcome;
+			typedef std::future<DescribeLiveEdgeTransferOutcome> DescribeLiveEdgeTransferOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveEdgeTransferRequest&, const DescribeLiveEdgeTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveEdgeTransferAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveIpInfoResult> DescribeLiveIpInfoOutcome;
+			typedef std::future<DescribeLiveIpInfoOutcome> DescribeLiveIpInfoOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveIpInfoRequest&, const DescribeLiveIpInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveIpInfoAsyncHandler;
 			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;
@@ -986,6 +1019,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveStreamSnapshotInfoResult> DescribeLiveStreamSnapshotInfoOutcome;
 			typedef std::future<DescribeLiveStreamSnapshotInfoOutcome> DescribeLiveStreamSnapshotInfoOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamSnapshotInfoRequest&, const DescribeLiveStreamSnapshotInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamSnapshotInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveStreamStateResult> DescribeLiveStreamStateOutcome;
+			typedef std::future<DescribeLiveStreamStateOutcome> DescribeLiveStreamStateOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamStateRequest&, const DescribeLiveStreamStateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamStateAsyncHandler;
 			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;
@@ -1076,12 +1112,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EnableLiveRealtimeLogDeliveryResult> EnableLiveRealtimeLogDeliveryOutcome;
 			typedef std::future<EnableLiveRealtimeLogDeliveryOutcome> EnableLiveRealtimeLogDeliveryOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::EnableLiveRealtimeLogDeliveryRequest&, const EnableLiveRealtimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableLiveRealtimeLogDeliveryAsyncHandler;
+			typedef Outcome<Error, Model::ForbidLiveCustomStreamResult> ForbidLiveCustomStreamOutcome;
+			typedef std::future<ForbidLiveCustomStreamOutcome> ForbidLiveCustomStreamOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::ForbidLiveCustomStreamRequest&, const ForbidLiveCustomStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidLiveCustomStreamAsyncHandler;
 			typedef Outcome<Error, Model::ForbidLiveStreamResult> ForbidLiveStreamOutcome;
 			typedef std::future<ForbidLiveStreamOutcome> ForbidLiveStreamOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::ForbidLiveStreamRequest&, const ForbidLiveStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidLiveStreamAsyncHandler;
 			typedef Outcome<Error, Model::ForbidPushStreamResult> ForbidPushStreamOutcome;
 			typedef std::future<ForbidPushStreamOutcome> ForbidPushStreamOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::ForbidPushStreamRequest&, const ForbidPushStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidPushStreamAsyncHandler;
+			typedef Outcome<Error, Model::GetCustomTemplateResult> GetCustomTemplateOutcome;
+			typedef std::future<GetCustomTemplateOutcome> GetCustomTemplateOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::GetCustomTemplateRequest&, const GetCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCustomTemplateAsyncHandler;
 			typedef Outcome<Error, Model::GetMultiRateConfigResult> GetMultiRateConfigOutcome;
 			typedef std::future<GetMultiRateConfigOutcome> GetMultiRateConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::GetMultiRateConfigRequest&, const GetMultiRateConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMultiRateConfigAsyncHandler;
@@ -1175,6 +1217,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetLiveDomainStagingConfigResult> SetLiveDomainStagingConfigOutcome;
 			typedef std::future<SetLiveDomainStagingConfigOutcome> SetLiveDomainStagingConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::SetLiveDomainStagingConfigRequest&, const SetLiveDomainStagingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveDomainStagingConfigAsyncHandler;
+			typedef Outcome<Error, Model::SetLiveEdgeTransferResult> SetLiveEdgeTransferOutcome;
+			typedef std::future<SetLiveEdgeTransferOutcome> SetLiveEdgeTransferOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::SetLiveEdgeTransferRequest&, const SetLiveEdgeTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveEdgeTransferAsyncHandler;
 			typedef Outcome<Error, Model::SetLiveLazyPullStreamInfoConfigResult> SetLiveLazyPullStreamInfoConfigOutcome;
 			typedef std::future<SetLiveLazyPullStreamInfoConfigOutcome> SetLiveLazyPullStreamInfoConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::SetLiveLazyPullStreamInfoConfigRequest&, const SetLiveLazyPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveLazyPullStreamInfoConfigAsyncHandler;
@@ -1402,6 +1447,9 @@ namespace AlibabaCloud
 			CreateCasterOutcome createCaster(const Model::CreateCasterRequest &request)const;
 			void createCasterAsync(const Model::CreateCasterRequest& request, const CreateCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCasterOutcomeCallable createCasterCallable(const Model::CreateCasterRequest& request) const;
+			CreateCustomTemplateOutcome createCustomTemplate(const Model::CreateCustomTemplateRequest &request)const;
+			void createCustomTemplateAsync(const Model::CreateCustomTemplateRequest& request, const CreateCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCustomTemplateOutcomeCallable createCustomTemplateCallable(const Model::CreateCustomTemplateRequest& request) const;
 			CreateLiveRealTimeLogDeliveryOutcome createLiveRealTimeLogDelivery(const Model::CreateLiveRealTimeLogDeliveryRequest &request)const;
 			void createLiveRealTimeLogDeliveryAsync(const Model::CreateLiveRealTimeLogDeliveryRequest& request, const CreateLiveRealTimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateLiveRealTimeLogDeliveryOutcomeCallable createLiveRealTimeLogDeliveryCallable(const Model::CreateLiveRealTimeLogDeliveryRequest& request) const;
@@ -1441,6 +1489,9 @@ namespace AlibabaCloud
 			DeleteCasterVideoResourceOutcome deleteCasterVideoResource(const Model::DeleteCasterVideoResourceRequest &request)const;
 			void deleteCasterVideoResourceAsync(const Model::DeleteCasterVideoResourceRequest& request, const DeleteCasterVideoResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteCasterVideoResourceOutcomeCallable deleteCasterVideoResourceCallable(const Model::DeleteCasterVideoResourceRequest& request) const;
+			DeleteCustomTemplateOutcome deleteCustomTemplate(const Model::DeleteCustomTemplateRequest &request)const;
+			void deleteCustomTemplateAsync(const Model::DeleteCustomTemplateRequest& request, const DeleteCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCustomTemplateOutcomeCallable deleteCustomTemplateCallable(const Model::DeleteCustomTemplateRequest& request) const;
 			DeleteHtmlResourceOutcome deleteHtmlResource(const Model::DeleteHtmlResourceRequest &request)const;
 			void deleteHtmlResourceAsync(const Model::DeleteHtmlResourceRequest& request, const DeleteHtmlResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteHtmlResourceOutcomeCallable deleteHtmlResourceCallable(const Model::DeleteHtmlResourceRequest& request) const;
@@ -1471,6 +1522,9 @@ namespace AlibabaCloud
 			DeleteLiveDomainPlayMappingOutcome deleteLiveDomainPlayMapping(const Model::DeleteLiveDomainPlayMappingRequest &request)const;
 			void deleteLiveDomainPlayMappingAsync(const Model::DeleteLiveDomainPlayMappingRequest& request, const DeleteLiveDomainPlayMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLiveDomainPlayMappingOutcomeCallable deleteLiveDomainPlayMappingCallable(const Model::DeleteLiveDomainPlayMappingRequest& request) const;
+			DeleteLiveEdgeTransferOutcome deleteLiveEdgeTransfer(const Model::DeleteLiveEdgeTransferRequest &request)const;
+			void deleteLiveEdgeTransferAsync(const Model::DeleteLiveEdgeTransferRequest& request, const DeleteLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteLiveEdgeTransferOutcomeCallable deleteLiveEdgeTransferCallable(const Model::DeleteLiveEdgeTransferRequest& request) const;
 			DeleteLiveLazyPullStreamInfoConfigOutcome deleteLiveLazyPullStreamInfoConfig(const Model::DeleteLiveLazyPullStreamInfoConfigRequest &request)const;
 			void deleteLiveLazyPullStreamInfoConfigAsync(const Model::DeleteLiveLazyPullStreamInfoConfigRequest& request, const DeleteLiveLazyPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLiveLazyPullStreamInfoConfigOutcomeCallable deleteLiveLazyPullStreamInfoConfigCallable(const Model::DeleteLiveLazyPullStreamInfoConfigRequest& request) const;
@@ -1675,6 +1729,12 @@ namespace AlibabaCloud
 			DescribeLiveDrmUsageDataOutcome describeLiveDrmUsageData(const Model::DescribeLiveDrmUsageDataRequest &request)const;
 			void describeLiveDrmUsageDataAsync(const Model::DescribeLiveDrmUsageDataRequest& request, const DescribeLiveDrmUsageDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDrmUsageDataOutcomeCallable describeLiveDrmUsageDataCallable(const Model::DescribeLiveDrmUsageDataRequest& request) const;
+			DescribeLiveEdgeTransferOutcome describeLiveEdgeTransfer(const Model::DescribeLiveEdgeTransferRequest &request)const;
+			void describeLiveEdgeTransferAsync(const Model::DescribeLiveEdgeTransferRequest& request, const DescribeLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveEdgeTransferOutcomeCallable describeLiveEdgeTransferCallable(const Model::DescribeLiveEdgeTransferRequest& request) const;
+			DescribeLiveIpInfoOutcome describeLiveIpInfo(const Model::DescribeLiveIpInfoRequest &request)const;
+			void describeLiveIpInfoAsync(const Model::DescribeLiveIpInfoRequest& request, const DescribeLiveIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveIpInfoOutcomeCallable describeLiveIpInfoCallable(const Model::DescribeLiveIpInfoRequest& request) const;
 			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;
@@ -1735,6 +1795,9 @@ namespace AlibabaCloud
 			DescribeLiveStreamSnapshotInfoOutcome describeLiveStreamSnapshotInfo(const Model::DescribeLiveStreamSnapshotInfoRequest &request)const;
 			void describeLiveStreamSnapshotInfoAsync(const Model::DescribeLiveStreamSnapshotInfoRequest& request, const DescribeLiveStreamSnapshotInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveStreamSnapshotInfoOutcomeCallable describeLiveStreamSnapshotInfoCallable(const Model::DescribeLiveStreamSnapshotInfoRequest& request) const;
+			DescribeLiveStreamStateOutcome describeLiveStreamState(const Model::DescribeLiveStreamStateRequest &request)const;
+			void describeLiveStreamStateAsync(const Model::DescribeLiveStreamStateRequest& request, const DescribeLiveStreamStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveStreamStateOutcomeCallable describeLiveStreamStateCallable(const Model::DescribeLiveStreamStateRequest& request) const;
 			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;
@@ -1825,12 +1888,18 @@ namespace AlibabaCloud
 			EnableLiveRealtimeLogDeliveryOutcome enableLiveRealtimeLogDelivery(const Model::EnableLiveRealtimeLogDeliveryRequest &request)const;
 			void enableLiveRealtimeLogDeliveryAsync(const Model::EnableLiveRealtimeLogDeliveryRequest& request, const EnableLiveRealtimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableLiveRealtimeLogDeliveryOutcomeCallable enableLiveRealtimeLogDeliveryCallable(const Model::EnableLiveRealtimeLogDeliveryRequest& request) const;
+			ForbidLiveCustomStreamOutcome forbidLiveCustomStream(const Model::ForbidLiveCustomStreamRequest &request)const;
+			void forbidLiveCustomStreamAsync(const Model::ForbidLiveCustomStreamRequest& request, const ForbidLiveCustomStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ForbidLiveCustomStreamOutcomeCallable forbidLiveCustomStreamCallable(const Model::ForbidLiveCustomStreamRequest& request) const;
 			ForbidLiveStreamOutcome forbidLiveStream(const Model::ForbidLiveStreamRequest &request)const;
 			void forbidLiveStreamAsync(const Model::ForbidLiveStreamRequest& request, const ForbidLiveStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ForbidLiveStreamOutcomeCallable forbidLiveStreamCallable(const Model::ForbidLiveStreamRequest& request) const;
 			ForbidPushStreamOutcome forbidPushStream(const Model::ForbidPushStreamRequest &request)const;
 			void forbidPushStreamAsync(const Model::ForbidPushStreamRequest& request, const ForbidPushStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ForbidPushStreamOutcomeCallable forbidPushStreamCallable(const Model::ForbidPushStreamRequest& request) const;
+			GetCustomTemplateOutcome getCustomTemplate(const Model::GetCustomTemplateRequest &request)const;
+			void getCustomTemplateAsync(const Model::GetCustomTemplateRequest& request, const GetCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCustomTemplateOutcomeCallable getCustomTemplateCallable(const Model::GetCustomTemplateRequest& request) const;
 			GetMultiRateConfigOutcome getMultiRateConfig(const Model::GetMultiRateConfigRequest &request)const;
 			void getMultiRateConfigAsync(const Model::GetMultiRateConfigRequest& request, const GetMultiRateConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetMultiRateConfigOutcomeCallable getMultiRateConfigCallable(const Model::GetMultiRateConfigRequest& request) const;
@@ -1924,6 +1993,9 @@ namespace AlibabaCloud
 			SetLiveDomainStagingConfigOutcome setLiveDomainStagingConfig(const Model::SetLiveDomainStagingConfigRequest &request)const;
 			void setLiveDomainStagingConfigAsync(const Model::SetLiveDomainStagingConfigRequest& request, const SetLiveDomainStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetLiveDomainStagingConfigOutcomeCallable setLiveDomainStagingConfigCallable(const Model::SetLiveDomainStagingConfigRequest& request) const;
+			SetLiveEdgeTransferOutcome setLiveEdgeTransfer(const Model::SetLiveEdgeTransferRequest &request)const;
+			void setLiveEdgeTransferAsync(const Model::SetLiveEdgeTransferRequest& request, const SetLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetLiveEdgeTransferOutcomeCallable setLiveEdgeTransferCallable(const Model::SetLiveEdgeTransferRequest& request) const;
 			SetLiveLazyPullStreamInfoConfigOutcome setLiveLazyPullStreamInfoConfig(const Model::SetLiveLazyPullStreamInfoConfigRequest &request)const;
 			void setLiveLazyPullStreamInfoConfigAsync(const Model::SetLiveLazyPullStreamInfoConfigRequest& request, const SetLiveLazyPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetLiveLazyPullStreamInfoConfigOutcomeCallable setLiveLazyPullStreamInfoConfigCallable(const Model::SetLiveLazyPullStreamInfoConfigRequest& request) const;

live/include/alibabacloud/live/model/AddCasterVideoResourceRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				AddCasterVideoResourceRequest();
 				~AddCasterVideoResourceRequest();
 
+				int getInputType()const;
+				void setInputType(int inputType);
 				int getEndOffset()const;
 				void setEndOffset(int endOffset);
 				std::string getMaterialId()const;
@@ -47,6 +49,8 @@ namespace AlibabaCloud
 				void setCasterId(const std::string& casterId);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				int getStreamMonitor()const;
+				void setStreamMonitor(int streamMonitor);
 				int getBeginOffset()const;
 				void setBeginOffset(int beginOffset);
 				std::string getLiveStreamUrl()const;
@@ -61,12 +65,14 @@ namespace AlibabaCloud
 				void setRepeatNum(int repeatNum);
 
             private:
+				int inputType_;
 				int endOffset_;
 				std::string materialId_;
 				std::string vodUrl_;
 				std::string streamId_;
 				std::string casterId_;
 				long ownerId_;
+				int streamMonitor_;
 				int beginOffset_;
 				std::string liveStreamUrl_;
 				std::string locationId_;

live/include/alibabacloud/live/model/AddLiveAppRecordConfigRequest.h

@@ -31,9 +31,18 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_LIVE_EXPORT AddLiveAppRecordConfigRequest : public RpcServiceRequest
 			{
 			public:
+				struct TranscodeRecordFormat
+				{
+					std::string sliceOssObjectPrefix;
+					int sliceDuration;
+					std::string format;
+					std::string ossObjectPrefix;
+					int cycleDuration;
+				};
 				struct RecordFormat
 				{
 					std::string sliceOssObjectPrefix;
+					int sliceDuration;
 					std::string format;
 					std::string ossObjectPrefix;
 					int cycleDuration;
@@ -45,12 +54,16 @@ namespace AlibabaCloud
 
 				std::string getOssEndpoint()const;
 				void setOssEndpoint(const std::string& ossEndpoint);
+				std::vector<std::string> getTranscodeTemplates()const;
+				void setTranscodeTemplates(const std::vector<std::string>& transcodeTemplates);
 				std::string getStartTime()const;
 				void setStartTime(const std::string& startTime);
 				std::string getAppName()const;
 				void setAppName(const std::string& appName);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
+				std::vector<TranscodeRecordFormat> getTranscodeRecordFormat()const;
+				void setTranscodeRecordFormat(const std::vector<TranscodeRecordFormat>& transcodeRecordFormat);
 				int getOnDemand()const;
 				void setOnDemand(int onDemand);
 				std::string getStreamName()const;
@@ -68,9 +81,11 @@ namespace AlibabaCloud
 
             private:
 				std::string ossEndpoint_;
+				std::vector<std::string> transcodeTemplates_;
 				std::string startTime_;
 				std::string appName_;
 				std::string securityToken_;
+				std::vector<TranscodeRecordFormat> transcodeRecordFormat_;
 				int onDemand_;
 				std::string streamName_;
 				std::string ossBucket_;

live/include/alibabacloud/live/model/CreateCustomTemplateRequest.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_CREATECUSTOMTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATEREQUEST_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 CreateCustomTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateCustomTemplateRequest();
+				~CreateCustomTemplateRequest();
+
+				std::string get_Template()const;
+				void set_Template(const std::string& _template);
+				std::string getCustomTemplate()const;
+				void setCustomTemplate(const std::string& customTemplate);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string _template_;
+				std::string customTemplate_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATEREQUEST_H_

live/include/alibabacloud/live/model/CreateCustomTemplateResult.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_CREATECUSTOMTEMPLATERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATERESULT_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 CreateCustomTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCustomTemplateResult();
+				explicit CreateCustomTemplateResult(const std::string &payload);
+				~CreateCustomTemplateResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATERESULT_H_

live/include/alibabacloud/live/model/DeleteCustomTemplateRequest.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_DELETECUSTOMTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATEREQUEST_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 DeleteCustomTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteCustomTemplateRequest();
+				~DeleteCustomTemplateRequest();
+
+				std::string get_Template()const;
+				void set_Template(const std::string& _template);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string _template_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATEREQUEST_H_

live/include/alibabacloud/live/model/DeleteCustomTemplateResult.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_DELETECUSTOMTEMPLATERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATERESULT_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 DeleteCustomTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteCustomTemplateResult();
+				explicit DeleteCustomTemplateResult(const std::string &payload);
+				~DeleteCustomTemplateResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATERESULT_H_

live/include/alibabacloud/live/model/DeleteLiveEdgeTransferRequest.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_DELETELIVEEDGETRANSFERREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERREQUEST_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 DeleteLiveEdgeTransferRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteLiveEdgeTransferRequest();
+				~DeleteLiveEdgeTransferRequest();
+
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERREQUEST_H_

live/include/alibabacloud/live/model/DeleteLiveEdgeTransferResult.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_DELETELIVEEDGETRANSFERRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERRESULT_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 DeleteLiveEdgeTransferResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteLiveEdgeTransferResult();
+				explicit DeleteLiveEdgeTransferResult(const std::string &payload);
+				~DeleteLiveEdgeTransferResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERRESULT_H_

live/include/alibabacloud/live/model/DescribeCasterChannelsResult.h

@@ -34,7 +34,10 @@ namespace AlibabaCloud
 			public:
 				struct Channel
 				{
+					std::string faceBeauty;
+					int inputType;
 					std::string resourceId;
+					std::string rtsUrl;
 					std::string channelId;
 					std::string streamUrl;
 					std::string rtmpUrl;

live/include/alibabacloud/live/model/DescribeCasterScenesResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 					std::string sceneName;
 					std::string layoutId;
 					std::vector<Scene::StreamInfo> streamInfos;
+					std::string rtsUrl;
 					std::string streamUrl;
 					std::string outputType;
 				};

live/include/alibabacloud/live/model/DescribeCasterVideoResourcesResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					int endOffset;
 					int beginOffset;
 					std::string materialId;
+					std::string flvUrl;
 					std::string resourceId;
 					std::string resourceName;
 					std::string locationId;

live/include/alibabacloud/live/model/DescribeLiveDomainRecordUsageDataResult.h

@@ -35,7 +35,7 @@ namespace AlibabaCloud
 				struct DataModule
 				{
 					std::string type;
-					long size;
+					long duration;
 					long count;
 					std::string domain;
 					std::string timeStamp;

live/include/alibabacloud/live/model/DescribeLiveEdgeTransferRequest.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_DESCRIBELIVEEDGETRANSFERREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEEDGETRANSFERREQUEST_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 DescribeLiveEdgeTransferRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveEdgeTransferRequest();
+				~DescribeLiveEdgeTransferRequest();
+
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEEDGETRANSFERREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveEdgeTransferResult.h

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

live/include/alibabacloud/live/model/DescribeLiveIpInfoRequest.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_DESCRIBELIVEIPINFOREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFOREQUEST_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 DescribeLiveIpInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveIpInfoRequest();
+				~DescribeLiveIpInfoRequest();
+
+				std::string getMethod()const;
+				void setMethod(const std::string& method);
+				std::string getIP()const;
+				void setIP(const std::string& iP);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string method_;
+				std::string iP_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFOREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveIpInfoResult.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_DESCRIBELIVEIPINFORESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFORESULT_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 DescribeLiveIpInfoResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeLiveIpInfoResult();
+				explicit DescribeLiveIpInfoResult(const std::string &payload);
+				~DescribeLiveIpInfoResult();
+				std::string getISP()const;
+				std::string getRegion()const;
+				std::string getIspEname()const;
+				std::string getRegionEname()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string iSP_;
+				std::string region_;
+				std::string ispEname_;
+				std::string regionEname_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFORESULT_H_

live/include/alibabacloud/live/model/DescribeLiveRecordConfigResult.h

@@ -39,6 +39,15 @@ namespace AlibabaCloud
 						std::string format;
 						std::string sliceOssObjectPrefix;
 						int cycleDuration;
+						int sliceDuration;
+						std::string ossObjectPrefix;
+					};
+					struct RecordFormat
+					{
+						std::string format;
+						std::string sliceOssObjectPrefix;
+						int cycleDuration;
+						int sliceDuration;
 						std::string ossObjectPrefix;
 					};
 					std::string streamName;
@@ -46,9 +55,11 @@ namespace AlibabaCloud
 					std::string endTime;
 					std::string domainName;
 					std::string createTime;
+					std::vector<std::string> transcodeTemplates;
 					std::string ossBucket;
 					std::string startTime;
 					std::vector<LiveAppRecord::RecordFormat> recordFormatList;
+					std::vector<LiveAppRecord::RecordFormat> transcodeRecordFormatList;
 					int onDemond;
 					std::string appName;
 				};

live/include/alibabacloud/live/model/DescribeLiveStreamStateRequest.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_DESCRIBELIVESTREAMSTATEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATEREQUEST_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 DescribeLiveStreamStateRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveStreamStateRequest();
+				~DescribeLiveStreamStateRequest();
+
+				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);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string appName_;
+				std::string streamName_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATEREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveStreamStateResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_DESCRIBELIVESTREAMSTATERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATERESULT_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 DescribeLiveStreamStateResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeLiveStreamStateResult();
+				explicit DescribeLiveStreamStateResult(const std::string &payload);
+				~DescribeLiveStreamStateResult();
+				std::string getStreamState()const;
+				std::string getType()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string streamState_;
+				std::string type_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATERESULT_H_

live/include/alibabacloud/live/model/DescribeLiveStreamsNotifyUrlConfigResult.h

@@ -36,7 +36,9 @@ namespace AlibabaCloud
 				{
 					std::string domainName;
 					std::string notifyUrl;
+					std::string notifyReqAuth;
 					std::string authKey;
+					std::string notifyAuthKey;
 					std::string authType;
 				};
 

live/include/alibabacloud/live/model/ForbidLiveCustomStreamRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMREQUEST_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 ForbidLiveCustomStreamRequest : public RpcServiceRequest
+			{
+
+			public:
+				ForbidLiveCustomStreamRequest();
+				~ForbidLiveCustomStreamRequest();
+
+				std::string getStyp()const;
+				void setStyp(const std::string& styp);
+				std::string getAppName()const;
+				void setAppName(const std::string& appName);
+				std::string getStreamName()const;
+				void setStreamName(const std::string& streamName);
+				std::string getControlStreamAction()const;
+				void setControlStreamAction(const std::string& controlStreamAction);
+				std::string getNeedwm()const;
+				void setNeedwm(const std::string& needwm);
+				std::string getResumeTime()const;
+				void setResumeTime(const std::string& resumeTime);
+				std::string getLiveStreamType()const;
+				void setLiveStreamType(const std::string& liveStreamType);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getSphd()const;
+				void setSphd(const std::string& sphd);
+				std::string getOneshot()const;
+				void setOneshot(const std::string& oneshot);
+				std::string getAppid()const;
+				void setAppid(const std::string& appid);
+				std::string getRatio()const;
+				void setRatio(const std::string& ratio);
+
+            private:
+				std::string styp_;
+				std::string appName_;
+				std::string streamName_;
+				std::string controlStreamAction_;
+				std::string needwm_;
+				std::string resumeTime_;
+				std::string liveStreamType_;
+				std::string domainName_;
+				long ownerId_;
+				std::string sphd_;
+				std::string oneshot_;
+				std::string appid_;
+				std::string ratio_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMREQUEST_H_

live/include/alibabacloud/live/model/ForbidLiveCustomStreamResult.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_FORBIDLIVECUSTOMSTREAMRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMRESULT_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 ForbidLiveCustomStreamResult : public ServiceResult
+			{
+			public:
+
+
+				ForbidLiveCustomStreamResult();
+				explicit ForbidLiveCustomStreamResult(const std::string &payload);
+				~ForbidLiveCustomStreamResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMRESULT_H_

live/include/alibabacloud/live/model/GetCustomTemplateRequest.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_GETCUSTOMTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATEREQUEST_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 GetCustomTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetCustomTemplateRequest();
+				~GetCustomTemplateRequest();
+
+				std::string get_Template()const;
+				void set_Template(const std::string& _template);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string _template_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATEREQUEST_H_

live/include/alibabacloud/live/model/GetCustomTemplateResult.h

@@ -0,0 +1,53 @@
+/*
+ * 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_GETCUSTOMTEMPLATERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATERESULT_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 GetCustomTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				GetCustomTemplateResult();
+				explicit GetCustomTemplateResult(const std::string &payload);
+				~GetCustomTemplateResult();
+				std::string get_Template()const;
+				std::string getCustomTemplate()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string _template_;
+				std::string customTemplate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATERESULT_H_

live/include/alibabacloud/live/model/SetCasterChannelRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				SetCasterChannelRequest();
 				~SetCasterChannelRequest();
 
+				std::string getFaceBeauty()const;
+				void setFaceBeauty(const std::string& faceBeauty);
 				int getSeekOffset()const;
 				void setSeekOffset(int seekOffset);
 				int getPlayStatus()const;
@@ -51,6 +53,7 @@ namespace AlibabaCloud
 				void setChannelId(const std::string& channelId);
 
             private:
+				std::string faceBeauty_;
 				int seekOffset_;
 				int playStatus_;
 				std::string resourceId_;

live/include/alibabacloud/live/model/SetCasterSyncGroupRequest.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					long syncDelayThreshold;
 					std::string hostResourceId;
 					std::vector<std::string> resourceIds;
+					std::vector<int> syncOffsets;
 				};
 
 			public:

live/include/alibabacloud/live/model/SetLiveEdgeTransferRequest.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_SETLIVEEDGETRANSFERREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERREQUEST_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 SetLiveEdgeTransferRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetLiveEdgeTransferRequest();
+				~SetLiveEdgeTransferRequest();
+
+				std::string getTransferArgs()const;
+				void setTransferArgs(const std::string& transferArgs);
+				std::string getAppName()const;
+				void setAppName(const std::string& appName);
+				std::string getStreamName()const;
+				void setStreamName(const std::string& streamName);
+				std::string getTargetDomainList()const;
+				void setTargetDomainList(const std::string& targetDomainList);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getHttpDns()const;
+				void setHttpDns(const std::string& httpDns);
+
+            private:
+				std::string transferArgs_;
+				std::string appName_;
+				std::string streamName_;
+				std::string targetDomainList_;
+				std::string domainName_;
+				long ownerId_;
+				std::string httpDns_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERREQUEST_H_

live/include/alibabacloud/live/model/SetLiveEdgeTransferResult.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_SETLIVEEDGETRANSFERRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERRESULT_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 SetLiveEdgeTransferResult : public ServiceResult
+			{
+			public:
+
+
+				SetLiveEdgeTransferResult();
+				explicit SetLiveEdgeTransferResult(const std::string &payload);
+				~SetLiveEdgeTransferResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERRESULT_H_

live/include/alibabacloud/live/model/SetLiveStreamsNotifyUrlConfigRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setAuthKey(const std::string& authKey);
 				std::string getAuthType()const;
 				void setAuthType(const std::string& authType);
+				std::string getNotifyReqAuth()const;
+				void setNotifyReqAuth(const std::string& notifyReqAuth);
 				std::string getNotifyUrl()const;
 				void setNotifyUrl(const std::string& notifyUrl);
 				std::string getNotifyType()const;
@@ -47,14 +49,18 @@ namespace AlibabaCloud
 				void setDomainName(const std::string& domainName);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				std::string getNotifyAuthKey()const;
+				void setNotifyAuthKey(const std::string& notifyAuthKey);
 
             private:
 				std::string authKey_;
 				std::string authType_;
+				std::string notifyReqAuth_;
 				std::string notifyUrl_;
 				std::string notifyType_;
 				std::string domainName_;
 				long ownerId_;
+				std::string notifyAuthKey_;
 
 			};
 		}

live/include/alibabacloud/live/model/StartCasterRequest.h

@@ -35,12 +35,15 @@ namespace AlibabaCloud
 				StartCasterRequest();
 				~StartCasterRequest();
 
+				int getPlayerType()const;
+				void setPlayerType(int playerType);
 				std::string getCasterId()const;
 				void setCasterId(const std::string& casterId);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 
             private:
+				int playerType_;
 				std::string casterId_;
 				long ownerId_;
 

live/include/alibabacloud/live/model/StartCasterResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct SceneInfo
 				{
 					std::string sceneId;
+					std::string rtsUrl;
 					std::string streamUrl;
 				};
 				struct SceneInfo1
@@ -47,6 +48,7 @@ namespace AlibabaCloud
 					};
 					std::string sceneId;
 					std::vector<SceneInfo1::StreamInfo> streamInfos;
+					std::string rtsUrl;
 					std::string streamUrl;
 				};
 

live/src/LiveClient.cc

@@ -1563,6 +1563,42 @@ LiveClient::CreateCasterOutcomeCallable LiveClient::createCasterCallable(const C
 	return task->get_future();
 }
 
+LiveClient::CreateCustomTemplateOutcome LiveClient::createCustomTemplate(const CreateCustomTemplateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCustomTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCustomTemplateOutcome(CreateCustomTemplateResult(outcome.result()));
+	else
+		return CreateCustomTemplateOutcome(outcome.error());
+}
+
+void LiveClient::createCustomTemplateAsync(const CreateCustomTemplateRequest& request, const CreateCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCustomTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::CreateCustomTemplateOutcomeCallable LiveClient::createCustomTemplateCallable(const CreateCustomTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCustomTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->createCustomTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::CreateLiveRealTimeLogDeliveryOutcome LiveClient::createLiveRealTimeLogDelivery(const CreateLiveRealTimeLogDeliveryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2031,6 +2067,42 @@ LiveClient::DeleteCasterVideoResourceOutcomeCallable LiveClient::deleteCasterVid
 	return task->get_future();
 }
 
+LiveClient::DeleteCustomTemplateOutcome LiveClient::deleteCustomTemplate(const DeleteCustomTemplateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteCustomTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteCustomTemplateOutcome(DeleteCustomTemplateResult(outcome.result()));
+	else
+		return DeleteCustomTemplateOutcome(outcome.error());
+}
+
+void LiveClient::deleteCustomTemplateAsync(const DeleteCustomTemplateRequest& request, const DeleteCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteCustomTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DeleteCustomTemplateOutcomeCallable LiveClient::deleteCustomTemplateCallable(const DeleteCustomTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteCustomTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteCustomTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DeleteHtmlResourceOutcome LiveClient::deleteHtmlResource(const DeleteHtmlResourceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2391,6 +2463,42 @@ LiveClient::DeleteLiveDomainPlayMappingOutcomeCallable LiveClient::deleteLiveDom
 	return task->get_future();
 }
 
+LiveClient::DeleteLiveEdgeTransferOutcome LiveClient::deleteLiveEdgeTransfer(const DeleteLiveEdgeTransferRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteLiveEdgeTransferOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteLiveEdgeTransferOutcome(DeleteLiveEdgeTransferResult(outcome.result()));
+	else
+		return DeleteLiveEdgeTransferOutcome(outcome.error());
+}
+
+void LiveClient::deleteLiveEdgeTransferAsync(const DeleteLiveEdgeTransferRequest& request, const DeleteLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteLiveEdgeTransfer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DeleteLiveEdgeTransferOutcomeCallable LiveClient::deleteLiveEdgeTransferCallable(const DeleteLiveEdgeTransferRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteLiveEdgeTransferOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteLiveEdgeTransfer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DeleteLiveLazyPullStreamInfoConfigOutcome LiveClient::deleteLiveLazyPullStreamInfoConfig(const DeleteLiveLazyPullStreamInfoConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4839,6 +4947,78 @@ LiveClient::DescribeLiveDrmUsageDataOutcomeCallable LiveClient::describeLiveDrmU
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveEdgeTransferOutcome LiveClient::describeLiveEdgeTransfer(const DescribeLiveEdgeTransferRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveEdgeTransferOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveEdgeTransferOutcome(DescribeLiveEdgeTransferResult(outcome.result()));
+	else
+		return DescribeLiveEdgeTransferOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveEdgeTransferAsync(const DescribeLiveEdgeTransferRequest& request, const DescribeLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveEdgeTransfer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveEdgeTransferOutcomeCallable LiveClient::describeLiveEdgeTransferCallable(const DescribeLiveEdgeTransferRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveEdgeTransferOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveEdgeTransfer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LiveClient::DescribeLiveIpInfoOutcome LiveClient::describeLiveIpInfo(const DescribeLiveIpInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveIpInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveIpInfoOutcome(DescribeLiveIpInfoResult(outcome.result()));
+	else
+		return DescribeLiveIpInfoOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveIpInfoAsync(const DescribeLiveIpInfoRequest& request, const DescribeLiveIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveIpInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveIpInfoOutcomeCallable LiveClient::describeLiveIpInfoCallable(const DescribeLiveIpInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveIpInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveIpInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveLazyPullStreamConfigOutcome LiveClient::describeLiveLazyPullStreamConfig(const DescribeLiveLazyPullStreamConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5559,6 +5739,42 @@ LiveClient::DescribeLiveStreamSnapshotInfoOutcomeCallable LiveClient::describeLi
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveStreamStateOutcome LiveClient::describeLiveStreamState(const DescribeLiveStreamStateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveStreamStateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveStreamStateOutcome(DescribeLiveStreamStateResult(outcome.result()));
+	else
+		return DescribeLiveStreamStateOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveStreamStateAsync(const DescribeLiveStreamStateRequest& request, const DescribeLiveStreamStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveStreamState(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveStreamStateOutcomeCallable LiveClient::describeLiveStreamStateCallable(const DescribeLiveStreamStateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveStreamStateOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveStreamState(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveStreamTranscodeInfoOutcome LiveClient::describeLiveStreamTranscodeInfo(const DescribeLiveStreamTranscodeInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6639,6 +6855,42 @@ LiveClient::EnableLiveRealtimeLogDeliveryOutcomeCallable LiveClient::enableLiveR
 	return task->get_future();
 }
 
+LiveClient::ForbidLiveCustomStreamOutcome LiveClient::forbidLiveCustomStream(const ForbidLiveCustomStreamRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ForbidLiveCustomStreamOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ForbidLiveCustomStreamOutcome(ForbidLiveCustomStreamResult(outcome.result()));
+	else
+		return ForbidLiveCustomStreamOutcome(outcome.error());
+}
+
+void LiveClient::forbidLiveCustomStreamAsync(const ForbidLiveCustomStreamRequest& request, const ForbidLiveCustomStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, forbidLiveCustomStream(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::ForbidLiveCustomStreamOutcomeCallable LiveClient::forbidLiveCustomStreamCallable(const ForbidLiveCustomStreamRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ForbidLiveCustomStreamOutcome()>>(
+			[this, request]()
+			{
+			return this->forbidLiveCustomStream(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::ForbidLiveStreamOutcome LiveClient::forbidLiveStream(const ForbidLiveStreamRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6711,6 +6963,42 @@ LiveClient::ForbidPushStreamOutcomeCallable LiveClient::forbidPushStreamCallable
 	return task->get_future();
 }
 
+LiveClient::GetCustomTemplateOutcome LiveClient::getCustomTemplate(const GetCustomTemplateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetCustomTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetCustomTemplateOutcome(GetCustomTemplateResult(outcome.result()));
+	else
+		return GetCustomTemplateOutcome(outcome.error());
+}
+
+void LiveClient::getCustomTemplateAsync(const GetCustomTemplateRequest& request, const GetCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getCustomTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::GetCustomTemplateOutcomeCallable LiveClient::getCustomTemplateCallable(const GetCustomTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetCustomTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->getCustomTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::GetMultiRateConfigOutcome LiveClient::getMultiRateConfig(const GetMultiRateConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7827,6 +8115,42 @@ LiveClient::SetLiveDomainStagingConfigOutcomeCallable LiveClient::setLiveDomainS
 	return task->get_future();
 }
 
+LiveClient::SetLiveEdgeTransferOutcome LiveClient::setLiveEdgeTransfer(const SetLiveEdgeTransferRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetLiveEdgeTransferOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetLiveEdgeTransferOutcome(SetLiveEdgeTransferResult(outcome.result()));
+	else
+		return SetLiveEdgeTransferOutcome(outcome.error());
+}
+
+void LiveClient::setLiveEdgeTransferAsync(const SetLiveEdgeTransferRequest& request, const SetLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setLiveEdgeTransfer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::SetLiveEdgeTransferOutcomeCallable LiveClient::setLiveEdgeTransferCallable(const SetLiveEdgeTransferRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetLiveEdgeTransferOutcome()>>(
+			[this, request]()
+			{
+			return this->setLiveEdgeTransfer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::SetLiveLazyPullStreamInfoConfigOutcome LiveClient::setLiveLazyPullStreamInfoConfig(const SetLiveLazyPullStreamInfoConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/AddCasterVideoResourceRequest.cc

@@ -27,6 +27,17 @@ AddCasterVideoResourceRequest::AddCasterVideoResourceRequest() :
 AddCasterVideoResourceRequest::~AddCasterVideoResourceRequest()
 {}
 
+int AddCasterVideoResourceRequest::getInputType()const
+{
+	return inputType_;
+}
+
+void AddCasterVideoResourceRequest::setInputType(int inputType)
+{
+	inputType_ = inputType;
+	setParameter("InputType", std::to_string(inputType));
+}
+
 int AddCasterVideoResourceRequest::getEndOffset()const
 {
 	return endOffset_;
@@ -93,6 +104,17 @@ void AddCasterVideoResourceRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+int AddCasterVideoResourceRequest::getStreamMonitor()const
+{
+	return streamMonitor_;
+}
+
+void AddCasterVideoResourceRequest::setStreamMonitor(int streamMonitor)
+{
+	streamMonitor_ = streamMonitor;
+	setParameter("StreamMonitor", std::to_string(streamMonitor));
+}
+
 int AddCasterVideoResourceRequest::getBeginOffset()const
 {
 	return beginOffset_;

live/src/model/AddLiveAppRecordConfigRequest.cc

@@ -38,6 +38,19 @@ void AddLiveAppRecordConfigRequest::setOssEndpoint(const std::string& ossEndpoin
 	setParameter("OssEndpoint", ossEndpoint);
 }
 
+std::vector<std::string> AddLiveAppRecordConfigRequest::getTranscodeTemplates()const
+{
+	return transcodeTemplates_;
+}
+
+void AddLiveAppRecordConfigRequest::setTranscodeTemplates(const std::vector<std::string>& transcodeTemplates)
+{
+	transcodeTemplates_ = transcodeTemplates;
+	for(int dep1 = 0; dep1!= transcodeTemplates.size(); dep1++) {
+		setParameter("TranscodeTemplates."+ std::to_string(dep1), transcodeTemplates.at(dep1));
+	}
+}
+
 std::string AddLiveAppRecordConfigRequest::getStartTime()const
 {
 	return startTime_;
@@ -71,6 +84,25 @@ void AddLiveAppRecordConfigRequest::setSecurityToken(const std::string& security
 	setParameter("SecurityToken", securityToken);
 }
 
+std::vector<AddLiveAppRecordConfigRequest::TranscodeRecordFormat> AddLiveAppRecordConfigRequest::getTranscodeRecordFormat()const
+{
+	return transcodeRecordFormat_;
+}
+
+void AddLiveAppRecordConfigRequest::setTranscodeRecordFormat(const std::vector<TranscodeRecordFormat>& transcodeRecordFormat)
+{
+	transcodeRecordFormat_ = transcodeRecordFormat;
+	for(int dep1 = 0; dep1!= transcodeRecordFormat.size(); dep1++) {
+		auto transcodeRecordFormatObj = transcodeRecordFormat.at(dep1);
+		std::string transcodeRecordFormatObjStr = "TranscodeRecordFormat." + std::to_string(dep1 + 1);
+		setParameter(transcodeRecordFormatObjStr + ".SliceOssObjectPrefix", transcodeRecordFormatObj.sliceOssObjectPrefix);
+		setParameter(transcodeRecordFormatObjStr + ".SliceDuration", std::to_string(transcodeRecordFormatObj.sliceDuration));
+		setParameter(transcodeRecordFormatObjStr + ".Format", transcodeRecordFormatObj.format);
+		setParameter(transcodeRecordFormatObjStr + ".OssObjectPrefix", transcodeRecordFormatObj.ossObjectPrefix);
+		setParameter(transcodeRecordFormatObjStr + ".CycleDuration", std::to_string(transcodeRecordFormatObj.cycleDuration));
+	}
+}
+
 int AddLiveAppRecordConfigRequest::getOnDemand()const
 {
 	return onDemand_;
@@ -149,6 +181,7 @@ void AddLiveAppRecordConfigRequest::setRecordFormat(const std::vector<RecordForm
 		auto recordFormatObj = recordFormat.at(dep1);
 		std::string recordFormatObjStr = "RecordFormat." + std::to_string(dep1 + 1);
 		setParameter(recordFormatObjStr + ".SliceOssObjectPrefix", recordFormatObj.sliceOssObjectPrefix);
+		setParameter(recordFormatObjStr + ".SliceDuration", std::to_string(recordFormatObj.sliceDuration));
 		setParameter(recordFormatObjStr + ".Format", recordFormatObj.format);
 		setParameter(recordFormatObjStr + ".OssObjectPrefix", recordFormatObj.ossObjectPrefix);
 		setParameter(recordFormatObjStr + ".CycleDuration", std::to_string(recordFormatObj.cycleDuration));

live/src/model/CreateCustomTemplateRequest.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/CreateCustomTemplateRequest.h>
+
+using AlibabaCloud::Live::Model::CreateCustomTemplateRequest;
+
+CreateCustomTemplateRequest::CreateCustomTemplateRequest() :
+	RpcServiceRequest("live", "2016-11-01", "CreateCustomTemplate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateCustomTemplateRequest::~CreateCustomTemplateRequest()
+{}
+
+std::string CreateCustomTemplateRequest::get_Template()const
+{
+	return _template_;
+}
+
+void CreateCustomTemplateRequest::set_Template(const std::string& _template)
+{
+	_template_ = _template;
+	setParameter("_Template", _template);
+}
+
+std::string CreateCustomTemplateRequest::getCustomTemplate()const
+{
+	return customTemplate_;
+}
+
+void CreateCustomTemplateRequest::setCustomTemplate(const std::string& customTemplate)
+{
+	customTemplate_ = customTemplate;
+	setParameter("CustomTemplate", customTemplate);
+}
+
+long CreateCustomTemplateRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateCustomTemplateRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

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

live/src/model/DeleteCustomTemplateRequest.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/DeleteCustomTemplateRequest.h>
+
+using AlibabaCloud::Live::Model::DeleteCustomTemplateRequest;
+
+DeleteCustomTemplateRequest::DeleteCustomTemplateRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DeleteCustomTemplate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteCustomTemplateRequest::~DeleteCustomTemplateRequest()
+{}
+
+std::string DeleteCustomTemplateRequest::get_Template()const
+{
+	return _template_;
+}
+
+void DeleteCustomTemplateRequest::set_Template(const std::string& _template)
+{
+	_template_ = _template;
+	setParameter("_Template", _template);
+}
+
+long DeleteCustomTemplateRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteCustomTemplateRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

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

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

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

live/src/model/DescribeCasterChannelsResult.cc

@@ -51,6 +51,12 @@ void DescribeCasterChannelsResult::parse(const std::string &payload)
 			channelsObject.streamUrl = valueChannelsChannel["StreamUrl"].asString();
 		if(!valueChannelsChannel["RtmpUrl"].isNull())
 			channelsObject.rtmpUrl = valueChannelsChannel["RtmpUrl"].asString();
+		if(!valueChannelsChannel["RtsUrl"].isNull())
+			channelsObject.rtsUrl = valueChannelsChannel["RtsUrl"].asString();
+		if(!valueChannelsChannel["InputType"].isNull())
+			channelsObject.inputType = std::stoi(valueChannelsChannel["InputType"].asString());
+		if(!valueChannelsChannel["FaceBeauty"].isNull())
+			channelsObject.faceBeauty = valueChannelsChannel["FaceBeauty"].asString();
 		channels_.push_back(channelsObject);
 	}
 	if(!value["Total"].isNull())

live/src/model/DescribeCasterScenesResult.cc

@@ -53,6 +53,8 @@ void DescribeCasterScenesResult::parse(const std::string &payload)
 			sceneListObject.layoutId = valueSceneListScene["LayoutId"].asString();
 		if(!valueSceneListScene["StreamUrl"].isNull())
 			sceneListObject.streamUrl = valueSceneListScene["StreamUrl"].asString();
+		if(!valueSceneListScene["RtsUrl"].isNull())
+			sceneListObject.rtsUrl = valueSceneListScene["RtsUrl"].asString();
 		if(!valueSceneListScene["Status"].isNull())
 			sceneListObject.status = std::stoi(valueSceneListScene["Status"].asString());
 		auto allStreamInfosNode = valueSceneListScene["StreamInfos"]["StreamInfo"];

live/src/model/DescribeCasterVideoResourcesResult.cc

@@ -53,6 +53,8 @@ void DescribeCasterVideoResourcesResult::parse(const std::string &payload)
 			videoResourcesObject.locationId = valueVideoResourcesVideoResource["LocationId"].asString();
 		if(!valueVideoResourcesVideoResource["LiveStreamUrl"].isNull())
 			videoResourcesObject.liveStreamUrl = valueVideoResourcesVideoResource["LiveStreamUrl"].asString();
+		if(!valueVideoResourcesVideoResource["FlvUrl"].isNull())
+			videoResourcesObject.flvUrl = valueVideoResourcesVideoResource["FlvUrl"].asString();
 		if(!valueVideoResourcesVideoResource["RepeatNum"].isNull())
 			videoResourcesObject.repeatNum = std::stoi(valueVideoResourcesVideoResource["RepeatNum"].asString());
 		if(!valueVideoResourcesVideoResource["VodUrl"].isNull())

live/src/model/DescribeLiveDomainRecordUsageDataResult.cc

@@ -49,8 +49,8 @@ void DescribeLiveDomainRecordUsageDataResult::parse(const std::string &payload)
 			recordUsageDataObject.domain = valueRecordUsageDataDataModule["Domain"].asString();
 		if(!valueRecordUsageDataDataModule["Type"].isNull())
 			recordUsageDataObject.type = valueRecordUsageDataDataModule["Type"].asString();
-		if(!valueRecordUsageDataDataModule["Size"].isNull())
-			recordUsageDataObject.size = std::stol(valueRecordUsageDataDataModule["Size"].asString());
+		if(!valueRecordUsageDataDataModule["Duration"].isNull())
+			recordUsageDataObject.duration = std::stol(valueRecordUsageDataDataModule["Duration"].asString());
 		if(!valueRecordUsageDataDataModule["Count"].isNull())
 			recordUsageDataObject.count = std::stol(valueRecordUsageDataDataModule["Count"].asString());
 		recordUsageData_.push_back(recordUsageDataObject);

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

live/src/model/DescribeLiveEdgeTransferResult.cc

@@ -0,0 +1,86 @@
+/*
+ * 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/DescribeLiveEdgeTransferResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveEdgeTransferResult::DescribeLiveEdgeTransferResult() :
+	ServiceResult()
+{}
+
+DescribeLiveEdgeTransferResult::DescribeLiveEdgeTransferResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveEdgeTransferResult::~DescribeLiveEdgeTransferResult()
+{}
+
+void DescribeLiveEdgeTransferResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+	if(!value["StreamName"].isNull())
+		streamName_ = value["StreamName"].asString();
+	if(!value["TargetDomainList"].isNull())
+		targetDomainList_ = value["TargetDomainList"].asString();
+	if(!value["TransferArgs"].isNull())
+		transferArgs_ = value["TransferArgs"].asString();
+	if(!value["HttpDns"].isNull())
+		httpDns_ = value["HttpDns"].asString();
+
+}
+
+std::string DescribeLiveEdgeTransferResult::getStreamName()const
+{
+	return streamName_;
+}
+
+std::string DescribeLiveEdgeTransferResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeLiveEdgeTransferResult::getTransferArgs()const
+{
+	return transferArgs_;
+}
+
+std::string DescribeLiveEdgeTransferResult::getHttpDns()const
+{
+	return httpDns_;
+}
+
+std::string DescribeLiveEdgeTransferResult::getAppName()const
+{
+	return appName_;
+}
+
+std::string DescribeLiveEdgeTransferResult::getTargetDomainList()const
+{
+	return targetDomainList_;
+}
+

live/src/model/DescribeLiveIpInfoRequest.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/DescribeLiveIpInfoRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveIpInfoRequest;
+
+DescribeLiveIpInfoRequest::DescribeLiveIpInfoRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveIpInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveIpInfoRequest::~DescribeLiveIpInfoRequest()
+{}
+
+std::string DescribeLiveIpInfoRequest::getMethod()const
+{
+	return method_;
+}
+
+void DescribeLiveIpInfoRequest::setMethod(const std::string& method)
+{
+	method_ = method;
+	setParameter("Method", method);
+}
+
+std::string DescribeLiveIpInfoRequest::getIP()const
+{
+	return iP_;
+}
+
+void DescribeLiveIpInfoRequest::setIP(const std::string& iP)
+{
+	iP_ = iP;
+	setParameter("IP", iP);
+}
+
+long DescribeLiveIpInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveIpInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveIpInfoResult.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/DescribeLiveIpInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveIpInfoResult::DescribeLiveIpInfoResult() :
+	ServiceResult()
+{}
+
+DescribeLiveIpInfoResult::DescribeLiveIpInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveIpInfoResult::~DescribeLiveIpInfoResult()
+{}
+
+void DescribeLiveIpInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ISP"].isNull())
+		iSP_ = value["ISP"].asString();
+	if(!value["IspEname"].isNull())
+		ispEname_ = value["IspEname"].asString();
+	if(!value["Region"].isNull())
+		region_ = value["Region"].asString();
+	if(!value["RegionEname"].isNull())
+		regionEname_ = value["RegionEname"].asString();
+
+}
+
+std::string DescribeLiveIpInfoResult::getISP()const
+{
+	return iSP_;
+}
+
+std::string DescribeLiveIpInfoResult::getRegion()const
+{
+	return region_;
+}
+
+std::string DescribeLiveIpInfoResult::getIspEname()const
+{
+	return ispEname_;
+}
+
+std::string DescribeLiveIpInfoResult::getRegionEname()const
+{
+	return regionEname_;
+}
+

live/src/model/DescribeLiveRecordConfigResult.cc

@@ -73,8 +73,29 @@ void DescribeLiveRecordConfigResult::parse(const std::string &payload)
 				recordFormatListObject.sliceOssObjectPrefix = valueLiveAppRecordListLiveAppRecordRecordFormatListRecordFormat["SliceOssObjectPrefix"].asString();
 			if(!valueLiveAppRecordListLiveAppRecordRecordFormatListRecordFormat["CycleDuration"].isNull())
 				recordFormatListObject.cycleDuration = std::stoi(valueLiveAppRecordListLiveAppRecordRecordFormatListRecordFormat["CycleDuration"].asString());
+			if(!valueLiveAppRecordListLiveAppRecordRecordFormatListRecordFormat["SliceDuration"].isNull())
+				recordFormatListObject.sliceDuration = std::stoi(valueLiveAppRecordListLiveAppRecordRecordFormatListRecordFormat["SliceDuration"].asString());
 			liveAppRecordListObject.recordFormatList.push_back(recordFormatListObject);
 		}
+		auto allTranscodeRecordFormatListNode = valueLiveAppRecordListLiveAppRecord["TranscodeRecordFormatList"]["RecordFormat"];
+		for (auto valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat : allTranscodeRecordFormatListNode)
+		{
+			LiveAppRecord::RecordFormat transcodeRecordFormatListObject;
+			if(!valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["Format"].isNull())
+				transcodeRecordFormatListObject.format = valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["Format"].asString();
+			if(!valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["OssObjectPrefix"].isNull())
+				transcodeRecordFormatListObject.ossObjectPrefix = valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["OssObjectPrefix"].asString();
+			if(!valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["SliceOssObjectPrefix"].isNull())
+				transcodeRecordFormatListObject.sliceOssObjectPrefix = valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["SliceOssObjectPrefix"].asString();
+			if(!valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["CycleDuration"].isNull())
+				transcodeRecordFormatListObject.cycleDuration = std::stoi(valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["CycleDuration"].asString());
+			if(!valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["SliceDuration"].isNull())
+				transcodeRecordFormatListObject.sliceDuration = std::stoi(valueLiveAppRecordListLiveAppRecordTranscodeRecordFormatListRecordFormat["SliceDuration"].asString());
+			liveAppRecordListObject.transcodeRecordFormatList.push_back(transcodeRecordFormatListObject);
+		}
+		auto allTranscodeTemplates = value["TranscodeTemplates"]["Templates"];
+		for (auto value : allTranscodeTemplates)
+			liveAppRecordListObject.transcodeTemplates.push_back(value.asString());
 		liveAppRecordList_.push_back(liveAppRecordListObject);
 	}
 	if(!value["PageNum"].isNull())

live/src/model/DescribeLiveStreamStateRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveStreamStateRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveStreamStateRequest;
+
+DescribeLiveStreamStateRequest::DescribeLiveStreamStateRequest() :
+	RpcServiceRequest("live", "2016-11-01", "DescribeLiveStreamState")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveStreamStateRequest::~DescribeLiveStreamStateRequest()
+{}
+
+std::string DescribeLiveStreamStateRequest::getAppName()const
+{
+	return appName_;
+}
+
+void DescribeLiveStreamStateRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setParameter("AppName", appName);
+}
+
+std::string DescribeLiveStreamStateRequest::getStreamName()const
+{
+	return streamName_;
+}
+
+void DescribeLiveStreamStateRequest::setStreamName(const std::string& streamName)
+{
+	streamName_ = streamName;
+	setParameter("StreamName", streamName);
+}
+
+std::string DescribeLiveStreamStateRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeLiveStreamStateRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeLiveStreamStateRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLiveStreamStateRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/DescribeLiveStreamStateResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/DescribeLiveStreamStateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveStreamStateResult::DescribeLiveStreamStateResult() :
+	ServiceResult()
+{}
+
+DescribeLiveStreamStateResult::DescribeLiveStreamStateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveStreamStateResult::~DescribeLiveStreamStateResult()
+{}
+
+void DescribeLiveStreamStateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["StreamState"].isNull())
+		streamState_ = value["StreamState"].asString();
+	if(!value["Type"].isNull())
+		type_ = value["Type"].asString();
+
+}
+
+std::string DescribeLiveStreamStateResult::getStreamState()const
+{
+	return streamState_;
+}
+
+std::string DescribeLiveStreamStateResult::getType()const
+{
+	return type_;
+}
+

live/src/model/DescribeLiveStreamsNotifyUrlConfigResult.cc

@@ -44,6 +44,10 @@ void DescribeLiveStreamsNotifyUrlConfigResult::parse(const std::string &payload)
 		liveStreamsNotifyConfig_.domainName = liveStreamsNotifyConfigNode["DomainName"].asString();
 	if(!liveStreamsNotifyConfigNode["NotifyUrl"].isNull())
 		liveStreamsNotifyConfig_.notifyUrl = liveStreamsNotifyConfigNode["NotifyUrl"].asString();
+	if(!liveStreamsNotifyConfigNode["NotifyReqAuth"].isNull())
+		liveStreamsNotifyConfig_.notifyReqAuth = liveStreamsNotifyConfigNode["NotifyReqAuth"].asString();
+	if(!liveStreamsNotifyConfigNode["NotifyAuthKey"].isNull())
+		liveStreamsNotifyConfig_.notifyAuthKey = liveStreamsNotifyConfigNode["NotifyAuthKey"].asString();
 	if(!liveStreamsNotifyConfigNode["AuthType"].isNull())
 		liveStreamsNotifyConfig_.authType = liveStreamsNotifyConfigNode["AuthType"].asString();
 	if(!liveStreamsNotifyConfigNode["AuthKey"].isNull())

live/src/model/ForbidLiveCustomStreamRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * 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/ForbidLiveCustomStreamRequest.h>
+
+using AlibabaCloud::Live::Model::ForbidLiveCustomStreamRequest;
+
+ForbidLiveCustomStreamRequest::ForbidLiveCustomStreamRequest() :
+	RpcServiceRequest("live", "2016-11-01", "ForbidLiveCustomStream")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ForbidLiveCustomStreamRequest::~ForbidLiveCustomStreamRequest()
+{}
+
+std::string ForbidLiveCustomStreamRequest::getStyp()const
+{
+	return styp_;
+}
+
+void ForbidLiveCustomStreamRequest::setStyp(const std::string& styp)
+{
+	styp_ = styp;
+	setParameter("Styp", styp);
+}
+
+std::string ForbidLiveCustomStreamRequest::getAppName()const
+{
+	return appName_;
+}
+
+void ForbidLiveCustomStreamRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setParameter("AppName", appName);
+}
+
+std::string ForbidLiveCustomStreamRequest::getStreamName()const
+{
+	return streamName_;
+}
+
+void ForbidLiveCustomStreamRequest::setStreamName(const std::string& streamName)
+{
+	streamName_ = streamName;
+	setParameter("StreamName", streamName);
+}
+
+std::string ForbidLiveCustomStreamRequest::getControlStreamAction()const
+{
+	return controlStreamAction_;
+}
+
+void ForbidLiveCustomStreamRequest::setControlStreamAction(const std::string& controlStreamAction)
+{
+	controlStreamAction_ = controlStreamAction;
+	setParameter("ControlStreamAction", controlStreamAction);
+}
+
+std::string ForbidLiveCustomStreamRequest::getNeedwm()const
+{
+	return needwm_;
+}
+
+void ForbidLiveCustomStreamRequest::setNeedwm(const std::string& needwm)
+{
+	needwm_ = needwm;
+	setParameter("Needwm", needwm);
+}
+
+std::string ForbidLiveCustomStreamRequest::getResumeTime()const
+{
+	return resumeTime_;
+}
+
+void ForbidLiveCustomStreamRequest::setResumeTime(const std::string& resumeTime)
+{
+	resumeTime_ = resumeTime;
+	setParameter("ResumeTime", resumeTime);
+}
+
+std::string ForbidLiveCustomStreamRequest::getLiveStreamType()const
+{
+	return liveStreamType_;
+}
+
+void ForbidLiveCustomStreamRequest::setLiveStreamType(const std::string& liveStreamType)
+{
+	liveStreamType_ = liveStreamType;
+	setParameter("LiveStreamType", liveStreamType);
+}
+
+std::string ForbidLiveCustomStreamRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void ForbidLiveCustomStreamRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long ForbidLiveCustomStreamRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ForbidLiveCustomStreamRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ForbidLiveCustomStreamRequest::getSphd()const
+{
+	return sphd_;
+}
+
+void ForbidLiveCustomStreamRequest::setSphd(const std::string& sphd)
+{
+	sphd_ = sphd;
+	setParameter("Sphd", sphd);
+}
+
+std::string ForbidLiveCustomStreamRequest::getOneshot()const
+{
+	return oneshot_;
+}
+
+void ForbidLiveCustomStreamRequest::setOneshot(const std::string& oneshot)
+{
+	oneshot_ = oneshot;
+	setParameter("Oneshot", oneshot);
+}
+
+std::string ForbidLiveCustomStreamRequest::getAppid()const
+{
+	return appid_;
+}
+
+void ForbidLiveCustomStreamRequest::setAppid(const std::string& appid)
+{
+	appid_ = appid;
+	setParameter("Appid", appid);
+}
+
+std::string ForbidLiveCustomStreamRequest::getRatio()const
+{
+	return ratio_;
+}
+
+void ForbidLiveCustomStreamRequest::setRatio(const std::string& ratio)
+{
+	ratio_ = ratio;
+	setParameter("Ratio", ratio);
+}
+

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

live/src/model/GetCustomTemplateRequest.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/GetCustomTemplateRequest.h>
+
+using AlibabaCloud::Live::Model::GetCustomTemplateRequest;
+
+GetCustomTemplateRequest::GetCustomTemplateRequest() :
+	RpcServiceRequest("live", "2016-11-01", "GetCustomTemplate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetCustomTemplateRequest::~GetCustomTemplateRequest()
+{}
+
+std::string GetCustomTemplateRequest::get_Template()const
+{
+	return _template_;
+}
+
+void GetCustomTemplateRequest::set_Template(const std::string& _template)
+{
+	_template_ = _template;
+	setParameter("_Template", _template);
+}
+
+long GetCustomTemplateRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void GetCustomTemplateRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

live/src/model/GetCustomTemplateResult.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/GetCustomTemplateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+GetCustomTemplateResult::GetCustomTemplateResult() :
+	ServiceResult()
+{}
+
+GetCustomTemplateResult::GetCustomTemplateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetCustomTemplateResult::~GetCustomTemplateResult()
+{}
+
+void GetCustomTemplateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Template"].isNull())
+		_template_ = value["Template"].asString();
+	if(!value["CustomTemplate"].isNull())
+		customTemplate_ = value["CustomTemplate"].asString();
+
+}
+
+std::string GetCustomTemplateResult::get_Template()const
+{
+	return _template_;
+}
+
+std::string GetCustomTemplateResult::getCustomTemplate()const
+{
+	return customTemplate_;
+}
+

live/src/model/SetCasterChannelRequest.cc

@@ -27,6 +27,17 @@ SetCasterChannelRequest::SetCasterChannelRequest() :
 SetCasterChannelRequest::~SetCasterChannelRequest()
 {}
 
+std::string SetCasterChannelRequest::getFaceBeauty()const
+{
+	return faceBeauty_;
+}
+
+void SetCasterChannelRequest::setFaceBeauty(const std::string& faceBeauty)
+{
+	faceBeauty_ = faceBeauty;
+	setParameter("FaceBeauty", faceBeauty);
+}
+
 int SetCasterChannelRequest::getSeekOffset()const
 {
 	return seekOffset_;

live/src/model/SetCasterSyncGroupRequest.cc

@@ -66,6 +66,9 @@ void SetCasterSyncGroupRequest::setSyncGroup(const std::vector<SyncGroup>& syncG
 		for(int dep2 = 0; dep2!= syncGroupObj.resourceIds.size(); dep2++) {
 			setParameter(syncGroupObjStr + ".ResourceIds."+ std::to_string(dep2), syncGroupObj.resourceIds.at(dep2));
 		}
+		for(int dep2 = 0; dep2!= syncGroupObj.syncOffsets.size(); dep2++) {
+			setParameter(syncGroupObjStr + ".SyncOffsets."+ std::to_string(dep2), std::to_string(syncGroupObj.syncOffsets.at(dep2)));
+		}
 	}
 }
 

live/src/model/SetLiveEdgeTransferRequest.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/SetLiveEdgeTransferRequest.h>
+
+using AlibabaCloud::Live::Model::SetLiveEdgeTransferRequest;
+
+SetLiveEdgeTransferRequest::SetLiveEdgeTransferRequest() :
+	RpcServiceRequest("live", "2016-11-01", "SetLiveEdgeTransfer")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetLiveEdgeTransferRequest::~SetLiveEdgeTransferRequest()
+{}
+
+std::string SetLiveEdgeTransferRequest::getTransferArgs()const
+{
+	return transferArgs_;
+}
+
+void SetLiveEdgeTransferRequest::setTransferArgs(const std::string& transferArgs)
+{
+	transferArgs_ = transferArgs;
+	setParameter("TransferArgs", transferArgs);
+}
+
+std::string SetLiveEdgeTransferRequest::getAppName()const
+{
+	return appName_;
+}
+
+void SetLiveEdgeTransferRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setParameter("AppName", appName);
+}
+
+std::string SetLiveEdgeTransferRequest::getStreamName()const
+{
+	return streamName_;
+}
+
+void SetLiveEdgeTransferRequest::setStreamName(const std::string& streamName)
+{
+	streamName_ = streamName;
+	setParameter("StreamName", streamName);
+}
+
+std::string SetLiveEdgeTransferRequest::getTargetDomainList()const
+{
+	return targetDomainList_;
+}
+
+void SetLiveEdgeTransferRequest::setTargetDomainList(const std::string& targetDomainList)
+{
+	targetDomainList_ = targetDomainList;
+	setParameter("TargetDomainList", targetDomainList);
+}
+
+std::string SetLiveEdgeTransferRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void SetLiveEdgeTransferRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long SetLiveEdgeTransferRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetLiveEdgeTransferRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetLiveEdgeTransferRequest::getHttpDns()const
+{
+	return httpDns_;
+}
+
+void SetLiveEdgeTransferRequest::setHttpDns(const std::string& httpDns)
+{
+	httpDns_ = httpDns;
+	setParameter("HttpDns", httpDns);
+}
+

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

live/src/model/SetLiveStreamsNotifyUrlConfigRequest.cc

@@ -49,6 +49,17 @@ void SetLiveStreamsNotifyUrlConfigRequest::setAuthType(const std::string& authTy
 	setParameter("AuthType", authType);
 }
 
+std::string SetLiveStreamsNotifyUrlConfigRequest::getNotifyReqAuth()const
+{
+	return notifyReqAuth_;
+}
+
+void SetLiveStreamsNotifyUrlConfigRequest::setNotifyReqAuth(const std::string& notifyReqAuth)
+{
+	notifyReqAuth_ = notifyReqAuth;
+	setParameter("NotifyReqAuth", notifyReqAuth);
+}
+
 std::string SetLiveStreamsNotifyUrlConfigRequest::getNotifyUrl()const
 {
 	return notifyUrl_;
@@ -93,3 +104,14 @@ void SetLiveStreamsNotifyUrlConfigRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+std::string SetLiveStreamsNotifyUrlConfigRequest::getNotifyAuthKey()const
+{
+	return notifyAuthKey_;
+}
+
+void SetLiveStreamsNotifyUrlConfigRequest::setNotifyAuthKey(const std::string& notifyAuthKey)
+{
+	notifyAuthKey_ = notifyAuthKey;
+	setParameter("NotifyAuthKey", notifyAuthKey);
+}
+

live/src/model/StartCasterRequest.cc

@@ -27,6 +27,17 @@ StartCasterRequest::StartCasterRequest() :
 StartCasterRequest::~StartCasterRequest()
 {}
 
+int StartCasterRequest::getPlayerType()const
+{
+	return playerType_;
+}
+
+void StartCasterRequest::setPlayerType(int playerType)
+{
+	playerType_ = playerType;
+	setParameter("PlayerType", std::to_string(playerType));
+}
+
 std::string StartCasterRequest::getCasterId()const
 {
 	return casterId_;

live/src/model/StartCasterResult.cc

@@ -47,6 +47,8 @@ void StartCasterResult::parse(const std::string &payload)
 			pvwSceneInfosObject.sceneId = valuePvwSceneInfosSceneInfo["SceneId"].asString();
 		if(!valuePvwSceneInfosSceneInfo["StreamUrl"].isNull())
 			pvwSceneInfosObject.streamUrl = valuePvwSceneInfosSceneInfo["StreamUrl"].asString();
+		if(!valuePvwSceneInfosSceneInfo["RtsUrl"].isNull())
+			pvwSceneInfosObject.rtsUrl = valuePvwSceneInfosSceneInfo["RtsUrl"].asString();
 		pvwSceneInfos_.push_back(pvwSceneInfosObject);
 	}
 	auto allPgmSceneInfosNode = value["PgmSceneInfos"]["SceneInfo"];
@@ -57,6 +59,8 @@ void StartCasterResult::parse(const std::string &payload)
 			pgmSceneInfosObject.sceneId = valuePgmSceneInfosSceneInfo["SceneId"].asString();
 		if(!valuePgmSceneInfosSceneInfo["StreamUrl"].isNull())
 			pgmSceneInfosObject.streamUrl = valuePgmSceneInfosSceneInfo["StreamUrl"].asString();
+		if(!valuePgmSceneInfosSceneInfo["RtsUrl"].isNull())
+			pgmSceneInfosObject.rtsUrl = valuePgmSceneInfosSceneInfo["RtsUrl"].asString();
 		auto allStreamInfosNode = valuePgmSceneInfosSceneInfo["StreamInfos"]["StreamInfo"];
 		for (auto valuePgmSceneInfosSceneInfoStreamInfosStreamInfo : allStreamInfosNode)
 		{