Live sdk update.

VERSION

@@ -1 +1 @@
-1.36.1512
+1.36.1513

live/CMakeLists.txt

@@ -87,6 +87,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/AllowPushStreamResult.h
 	include/alibabacloud/live/model/BatchDeleteLiveDomainConfigsRequest.h
 	include/alibabacloud/live/model/BatchDeleteLiveDomainConfigsResult.h
+	include/alibabacloud/live/model/BatchGetOnlineUsersRequest.h
+	include/alibabacloud/live/model/BatchGetOnlineUsersResult.h
 	include/alibabacloud/live/model/BatchSetLiveDomainConfigsRequest.h
 	include/alibabacloud/live/model/BatchSetLiveDomainConfigsResult.h
 	include/alibabacloud/live/model/CancelMuteAllGroupUserRequest.h
@@ -103,6 +105,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/CreateCasterResult.h
 	include/alibabacloud/live/model/CreateCustomTemplateRequest.h
 	include/alibabacloud/live/model/CreateCustomTemplateResult.h
+	include/alibabacloud/live/model/CreateLiveDelayConfigRequest.h
+	include/alibabacloud/live/model/CreateLiveDelayConfigResult.h
 	include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryRequest.h
 	include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryResult.h
 	include/alibabacloud/live/model/CreateLiveStreamMonitorRequest.h
@@ -145,6 +149,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DeleteLiveAudioAuditNotifyConfigResult.h
 	include/alibabacloud/live/model/DeleteLiveCenterTransferRequest.h
 	include/alibabacloud/live/model/DeleteLiveCenterTransferResult.h
+	include/alibabacloud/live/model/DeleteLiveDelayConfigRequest.h
+	include/alibabacloud/live/model/DeleteLiveDelayConfigResult.h
 	include/alibabacloud/live/model/DeleteLiveDetectNotifyConfigRequest.h
 	include/alibabacloud/live/model/DeleteLiveDetectNotifyConfigResult.h
 	include/alibabacloud/live/model/DeleteLiveDomainRequest.h
@@ -245,6 +251,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveCertificateDetailResult.h
 	include/alibabacloud/live/model/DescribeLiveCertificateListRequest.h
 	include/alibabacloud/live/model/DescribeLiveCertificateListResult.h
+	include/alibabacloud/live/model/DescribeLiveDelayConfigRequest.h
+	include/alibabacloud/live/model/DescribeLiveDelayConfigResult.h
 	include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageRequest.h
 	include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageResult.h
 	include/alibabacloud/live/model/DescribeLiveDetectNotifyConfigRequest.h
@@ -321,6 +329,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveRecordConfigResult.h
 	include/alibabacloud/live/model/DescribeLiveRecordNotifyConfigRequest.h
 	include/alibabacloud/live/model/DescribeLiveRecordNotifyConfigResult.h
+	include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsRequest.h
+	include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsResult.h
 	include/alibabacloud/live/model/DescribeLiveRecordVodConfigsRequest.h
 	include/alibabacloud/live/model/DescribeLiveRecordVodConfigsResult.h
 	include/alibabacloud/live/model/DescribeLiveShiftConfigsRequest.h
@@ -465,6 +475,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/JoinMessageGroupResult.h
 	include/alibabacloud/live/model/LeaveMessageGroupRequest.h
 	include/alibabacloud/live/model/LeaveMessageGroupResult.h
+	include/alibabacloud/live/model/ListLiveDelayConfigRequest.h
+	include/alibabacloud/live/model/ListLiveDelayConfigResult.h
 	include/alibabacloud/live/model/ListLiveRealtimeLogDeliveryRequest.h
 	include/alibabacloud/live/model/ListLiveRealtimeLogDeliveryResult.h
 	include/alibabacloud/live/model/ListLiveRealtimeLogDeliveryDomainsRequest.h
@@ -603,6 +615,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/UpdateLiveAudioAuditNotifyConfigResult.h
 	include/alibabacloud/live/model/UpdateLiveCenterTransferRequest.h
 	include/alibabacloud/live/model/UpdateLiveCenterTransferResult.h
+	include/alibabacloud/live/model/UpdateLiveDelayConfigRequest.h
+	include/alibabacloud/live/model/UpdateLiveDelayConfigResult.h
 	include/alibabacloud/live/model/UpdateLiveDetectNotifyConfigRequest.h
 	include/alibabacloud/live/model/UpdateLiveDetectNotifyConfigResult.h
 	include/alibabacloud/live/model/UpdateLivePullStreamInfoConfigRequest.h
@@ -698,6 +712,8 @@ set(live_src
 	src/model/AllowPushStreamResult.cc
 	src/model/BatchDeleteLiveDomainConfigsRequest.cc
 	src/model/BatchDeleteLiveDomainConfigsResult.cc
+	src/model/BatchGetOnlineUsersRequest.cc
+	src/model/BatchGetOnlineUsersResult.cc
 	src/model/BatchSetLiveDomainConfigsRequest.cc
 	src/model/BatchSetLiveDomainConfigsResult.cc
 	src/model/CancelMuteAllGroupUserRequest.cc
@@ -714,6 +730,8 @@ set(live_src
 	src/model/CreateCasterResult.cc
 	src/model/CreateCustomTemplateRequest.cc
 	src/model/CreateCustomTemplateResult.cc
+	src/model/CreateLiveDelayConfigRequest.cc
+	src/model/CreateLiveDelayConfigResult.cc
 	src/model/CreateLiveRealTimeLogDeliveryRequest.cc
 	src/model/CreateLiveRealTimeLogDeliveryResult.cc
 	src/model/CreateLiveStreamMonitorRequest.cc
@@ -756,6 +774,8 @@ set(live_src
 	src/model/DeleteLiveAudioAuditNotifyConfigResult.cc
 	src/model/DeleteLiveCenterTransferRequest.cc
 	src/model/DeleteLiveCenterTransferResult.cc
+	src/model/DeleteLiveDelayConfigRequest.cc
+	src/model/DeleteLiveDelayConfigResult.cc
 	src/model/DeleteLiveDetectNotifyConfigRequest.cc
 	src/model/DeleteLiveDetectNotifyConfigResult.cc
 	src/model/DeleteLiveDomainRequest.cc
@@ -856,6 +876,8 @@ set(live_src
 	src/model/DescribeLiveCertificateDetailResult.cc
 	src/model/DescribeLiveCertificateListRequest.cc
 	src/model/DescribeLiveCertificateListResult.cc
+	src/model/DescribeLiveDelayConfigRequest.cc
+	src/model/DescribeLiveDelayConfigResult.cc
 	src/model/DescribeLiveDelayedStreamingUsageRequest.cc
 	src/model/DescribeLiveDelayedStreamingUsageResult.cc
 	src/model/DescribeLiveDetectNotifyConfigRequest.cc
@@ -932,6 +954,8 @@ set(live_src
 	src/model/DescribeLiveRecordConfigResult.cc
 	src/model/DescribeLiveRecordNotifyConfigRequest.cc
 	src/model/DescribeLiveRecordNotifyConfigResult.cc
+	src/model/DescribeLiveRecordNotifyRecordsRequest.cc
+	src/model/DescribeLiveRecordNotifyRecordsResult.cc
 	src/model/DescribeLiveRecordVodConfigsRequest.cc
 	src/model/DescribeLiveRecordVodConfigsResult.cc
 	src/model/DescribeLiveShiftConfigsRequest.cc
@@ -1076,6 +1100,8 @@ set(live_src
 	src/model/JoinMessageGroupResult.cc
 	src/model/LeaveMessageGroupRequest.cc
 	src/model/LeaveMessageGroupResult.cc
+	src/model/ListLiveDelayConfigRequest.cc
+	src/model/ListLiveDelayConfigResult.cc
 	src/model/ListLiveRealtimeLogDeliveryRequest.cc
 	src/model/ListLiveRealtimeLogDeliveryResult.cc
 	src/model/ListLiveRealtimeLogDeliveryDomainsRequest.cc
@@ -1214,6 +1240,8 @@ set(live_src
 	src/model/UpdateLiveAudioAuditNotifyConfigResult.cc
 	src/model/UpdateLiveCenterTransferRequest.cc
 	src/model/UpdateLiveCenterTransferResult.cc
+	src/model/UpdateLiveDelayConfigRequest.cc
+	src/model/UpdateLiveDelayConfigResult.cc
 	src/model/UpdateLiveDetectNotifyConfigRequest.cc
 	src/model/UpdateLiveDetectNotifyConfigResult.cc
 	src/model/UpdateLivePullStreamInfoConfigRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -88,6 +88,8 @@
 #include "model/AllowPushStreamResult.h"
 #include "model/BatchDeleteLiveDomainConfigsRequest.h"
 #include "model/BatchDeleteLiveDomainConfigsResult.h"
+#include "model/BatchGetOnlineUsersRequest.h"
+#include "model/BatchGetOnlineUsersResult.h"
 #include "model/BatchSetLiveDomainConfigsRequest.h"
 #include "model/BatchSetLiveDomainConfigsResult.h"
 #include "model/CancelMuteAllGroupUserRequest.h"
@@ -104,6 +106,8 @@
 #include "model/CreateCasterResult.h"
 #include "model/CreateCustomTemplateRequest.h"
 #include "model/CreateCustomTemplateResult.h"
+#include "model/CreateLiveDelayConfigRequest.h"
+#include "model/CreateLiveDelayConfigResult.h"
 #include "model/CreateLiveRealTimeLogDeliveryRequest.h"
 #include "model/CreateLiveRealTimeLogDeliveryResult.h"
 #include "model/CreateLiveStreamMonitorRequest.h"
@@ -146,6 +150,8 @@
 #include "model/DeleteLiveAudioAuditNotifyConfigResult.h"
 #include "model/DeleteLiveCenterTransferRequest.h"
 #include "model/DeleteLiveCenterTransferResult.h"
+#include "model/DeleteLiveDelayConfigRequest.h"
+#include "model/DeleteLiveDelayConfigResult.h"
 #include "model/DeleteLiveDetectNotifyConfigRequest.h"
 #include "model/DeleteLiveDetectNotifyConfigResult.h"
 #include "model/DeleteLiveDomainRequest.h"
@@ -246,6 +252,8 @@
 #include "model/DescribeLiveCertificateDetailResult.h"
 #include "model/DescribeLiveCertificateListRequest.h"
 #include "model/DescribeLiveCertificateListResult.h"
+#include "model/DescribeLiveDelayConfigRequest.h"
+#include "model/DescribeLiveDelayConfigResult.h"
 #include "model/DescribeLiveDelayedStreamingUsageRequest.h"
 #include "model/DescribeLiveDelayedStreamingUsageResult.h"
 #include "model/DescribeLiveDetectNotifyConfigRequest.h"
@@ -322,6 +330,8 @@
 #include "model/DescribeLiveRecordConfigResult.h"
 #include "model/DescribeLiveRecordNotifyConfigRequest.h"
 #include "model/DescribeLiveRecordNotifyConfigResult.h"
+#include "model/DescribeLiveRecordNotifyRecordsRequest.h"
+#include "model/DescribeLiveRecordNotifyRecordsResult.h"
 #include "model/DescribeLiveRecordVodConfigsRequest.h"
 #include "model/DescribeLiveRecordVodConfigsResult.h"
 #include "model/DescribeLiveShiftConfigsRequest.h"
@@ -466,6 +476,8 @@
 #include "model/JoinMessageGroupResult.h"
 #include "model/LeaveMessageGroupRequest.h"
 #include "model/LeaveMessageGroupResult.h"
+#include "model/ListLiveDelayConfigRequest.h"
+#include "model/ListLiveDelayConfigResult.h"
 #include "model/ListLiveRealtimeLogDeliveryRequest.h"
 #include "model/ListLiveRealtimeLogDeliveryResult.h"
 #include "model/ListLiveRealtimeLogDeliveryDomainsRequest.h"
@@ -604,6 +616,8 @@
 #include "model/UpdateLiveAudioAuditNotifyConfigResult.h"
 #include "model/UpdateLiveCenterTransferRequest.h"
 #include "model/UpdateLiveCenterTransferResult.h"
+#include "model/UpdateLiveDelayConfigRequest.h"
+#include "model/UpdateLiveDelayConfigResult.h"
 #include "model/UpdateLiveDetectNotifyConfigRequest.h"
 #include "model/UpdateLiveDetectNotifyConfigResult.h"
 #include "model/UpdateLivePullStreamInfoConfigRequest.h"
@@ -738,6 +752,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::BatchDeleteLiveDomainConfigsResult> BatchDeleteLiveDomainConfigsOutcome;
 			typedef std::future<BatchDeleteLiveDomainConfigsOutcome> BatchDeleteLiveDomainConfigsOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::BatchDeleteLiveDomainConfigsRequest&, const BatchDeleteLiveDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteLiveDomainConfigsAsyncHandler;
+			typedef Outcome<Error, Model::BatchGetOnlineUsersResult> BatchGetOnlineUsersOutcome;
+			typedef std::future<BatchGetOnlineUsersOutcome> BatchGetOnlineUsersOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::BatchGetOnlineUsersRequest&, const BatchGetOnlineUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchGetOnlineUsersAsyncHandler;
 			typedef Outcome<Error, Model::BatchSetLiveDomainConfigsResult> BatchSetLiveDomainConfigsOutcome;
 			typedef std::future<BatchSetLiveDomainConfigsOutcome> BatchSetLiveDomainConfigsOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::BatchSetLiveDomainConfigsRequest&, const BatchSetLiveDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchSetLiveDomainConfigsAsyncHandler;
@@ -762,6 +779,9 @@ namespace AlibabaCloud
 			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::CreateLiveDelayConfigResult> CreateLiveDelayConfigOutcome;
+			typedef std::future<CreateLiveDelayConfigOutcome> CreateLiveDelayConfigOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::CreateLiveDelayConfigRequest&, const CreateLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveDelayConfigAsyncHandler;
 			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;
@@ -825,6 +845,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteLiveCenterTransferResult> DeleteLiveCenterTransferOutcome;
 			typedef std::future<DeleteLiveCenterTransferOutcome> DeleteLiveCenterTransferOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteLiveCenterTransferRequest&, const DeleteLiveCenterTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveCenterTransferAsyncHandler;
+			typedef Outcome<Error, Model::DeleteLiveDelayConfigResult> DeleteLiveDelayConfigOutcome;
+			typedef std::future<DeleteLiveDelayConfigOutcome> DeleteLiveDelayConfigOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DeleteLiveDelayConfigRequest&, const DeleteLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDelayConfigAsyncHandler;
 			typedef Outcome<Error, Model::DeleteLiveDetectNotifyConfigResult> DeleteLiveDetectNotifyConfigOutcome;
 			typedef std::future<DeleteLiveDetectNotifyConfigOutcome> DeleteLiveDetectNotifyConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteLiveDetectNotifyConfigRequest&, const DeleteLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDetectNotifyConfigAsyncHandler;
@@ -975,6 +998,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveCertificateListResult> DescribeLiveCertificateListOutcome;
 			typedef std::future<DescribeLiveCertificateListOutcome> DescribeLiveCertificateListOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveCertificateListRequest&, const DescribeLiveCertificateListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveCertificateListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveDelayConfigResult> DescribeLiveDelayConfigOutcome;
+			typedef std::future<DescribeLiveDelayConfigOutcome> DescribeLiveDelayConfigOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDelayConfigRequest&, const DescribeLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDelayConfigAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveDelayedStreamingUsageResult> DescribeLiveDelayedStreamingUsageOutcome;
 			typedef std::future<DescribeLiveDelayedStreamingUsageOutcome> DescribeLiveDelayedStreamingUsageOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDelayedStreamingUsageRequest&, const DescribeLiveDelayedStreamingUsageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDelayedStreamingUsageAsyncHandler;
@@ -1089,6 +1115,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveRecordNotifyConfigResult> DescribeLiveRecordNotifyConfigOutcome;
 			typedef std::future<DescribeLiveRecordNotifyConfigOutcome> DescribeLiveRecordNotifyConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordNotifyConfigRequest&, const DescribeLiveRecordNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordNotifyConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveRecordNotifyRecordsResult> DescribeLiveRecordNotifyRecordsOutcome;
+			typedef std::future<DescribeLiveRecordNotifyRecordsOutcome> DescribeLiveRecordNotifyRecordsOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordNotifyRecordsRequest&, const DescribeLiveRecordNotifyRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordNotifyRecordsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveRecordVodConfigsResult> DescribeLiveRecordVodConfigsOutcome;
 			typedef std::future<DescribeLiveRecordVodConfigsOutcome> DescribeLiveRecordVodConfigsOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordVodConfigsRequest&, const DescribeLiveRecordVodConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordVodConfigsAsyncHandler;
@@ -1305,6 +1334,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::LeaveMessageGroupResult> LeaveMessageGroupOutcome;
 			typedef std::future<LeaveMessageGroupOutcome> LeaveMessageGroupOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::LeaveMessageGroupRequest&, const LeaveMessageGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LeaveMessageGroupAsyncHandler;
+			typedef Outcome<Error, Model::ListLiveDelayConfigResult> ListLiveDelayConfigOutcome;
+			typedef std::future<ListLiveDelayConfigOutcome> ListLiveDelayConfigOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::ListLiveDelayConfigRequest&, const ListLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLiveDelayConfigAsyncHandler;
 			typedef Outcome<Error, Model::ListLiveRealtimeLogDeliveryResult> ListLiveRealtimeLogDeliveryOutcome;
 			typedef std::future<ListLiveRealtimeLogDeliveryOutcome> ListLiveRealtimeLogDeliveryOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::ListLiveRealtimeLogDeliveryRequest&, const ListLiveRealtimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLiveRealtimeLogDeliveryAsyncHandler;
@@ -1512,6 +1544,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateLiveCenterTransferResult> UpdateLiveCenterTransferOutcome;
 			typedef std::future<UpdateLiveCenterTransferOutcome> UpdateLiveCenterTransferOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::UpdateLiveCenterTransferRequest&, const UpdateLiveCenterTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveCenterTransferAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLiveDelayConfigResult> UpdateLiveDelayConfigOutcome;
+			typedef std::future<UpdateLiveDelayConfigOutcome> UpdateLiveDelayConfigOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::UpdateLiveDelayConfigRequest&, const UpdateLiveDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveDelayConfigAsyncHandler;
 			typedef Outcome<Error, Model::UpdateLiveDetectNotifyConfigResult> UpdateLiveDetectNotifyConfigOutcome;
 			typedef std::future<UpdateLiveDetectNotifyConfigOutcome> UpdateLiveDetectNotifyConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::UpdateLiveDetectNotifyConfigRequest&, const UpdateLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveDetectNotifyConfigAsyncHandler;
@@ -1655,6 +1690,9 @@ namespace AlibabaCloud
 			BatchDeleteLiveDomainConfigsOutcome batchDeleteLiveDomainConfigs(const Model::BatchDeleteLiveDomainConfigsRequest &request)const;
 			void batchDeleteLiveDomainConfigsAsync(const Model::BatchDeleteLiveDomainConfigsRequest& request, const BatchDeleteLiveDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			BatchDeleteLiveDomainConfigsOutcomeCallable batchDeleteLiveDomainConfigsCallable(const Model::BatchDeleteLiveDomainConfigsRequest& request) const;
+			BatchGetOnlineUsersOutcome batchGetOnlineUsers(const Model::BatchGetOnlineUsersRequest &request)const;
+			void batchGetOnlineUsersAsync(const Model::BatchGetOnlineUsersRequest& request, const BatchGetOnlineUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BatchGetOnlineUsersOutcomeCallable batchGetOnlineUsersCallable(const Model::BatchGetOnlineUsersRequest& request) const;
 			BatchSetLiveDomainConfigsOutcome batchSetLiveDomainConfigs(const Model::BatchSetLiveDomainConfigsRequest &request)const;
 			void batchSetLiveDomainConfigsAsync(const Model::BatchSetLiveDomainConfigsRequest& request, const BatchSetLiveDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			BatchSetLiveDomainConfigsOutcomeCallable batchSetLiveDomainConfigsCallable(const Model::BatchSetLiveDomainConfigsRequest& request) const;
@@ -1679,6 +1717,9 @@ namespace AlibabaCloud
 			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;
+			CreateLiveDelayConfigOutcome createLiveDelayConfig(const Model::CreateLiveDelayConfigRequest &request)const;
+			void createLiveDelayConfigAsync(const Model::CreateLiveDelayConfigRequest& request, const CreateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateLiveDelayConfigOutcomeCallable createLiveDelayConfigCallable(const Model::CreateLiveDelayConfigRequest& 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;
@@ -1742,6 +1783,9 @@ namespace AlibabaCloud
 			DeleteLiveCenterTransferOutcome deleteLiveCenterTransfer(const Model::DeleteLiveCenterTransferRequest &request)const;
 			void deleteLiveCenterTransferAsync(const Model::DeleteLiveCenterTransferRequest& request, const DeleteLiveCenterTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLiveCenterTransferOutcomeCallable deleteLiveCenterTransferCallable(const Model::DeleteLiveCenterTransferRequest& request) const;
+			DeleteLiveDelayConfigOutcome deleteLiveDelayConfig(const Model::DeleteLiveDelayConfigRequest &request)const;
+			void deleteLiveDelayConfigAsync(const Model::DeleteLiveDelayConfigRequest& request, const DeleteLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteLiveDelayConfigOutcomeCallable deleteLiveDelayConfigCallable(const Model::DeleteLiveDelayConfigRequest& request) const;
 			DeleteLiveDetectNotifyConfigOutcome deleteLiveDetectNotifyConfig(const Model::DeleteLiveDetectNotifyConfigRequest &request)const;
 			void deleteLiveDetectNotifyConfigAsync(const Model::DeleteLiveDetectNotifyConfigRequest& request, const DeleteLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLiveDetectNotifyConfigOutcomeCallable deleteLiveDetectNotifyConfigCallable(const Model::DeleteLiveDetectNotifyConfigRequest& request) const;
@@ -1892,6 +1936,9 @@ namespace AlibabaCloud
 			DescribeLiveCertificateListOutcome describeLiveCertificateList(const Model::DescribeLiveCertificateListRequest &request)const;
 			void describeLiveCertificateListAsync(const Model::DescribeLiveCertificateListRequest& request, const DescribeLiveCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveCertificateListOutcomeCallable describeLiveCertificateListCallable(const Model::DescribeLiveCertificateListRequest& request) const;
+			DescribeLiveDelayConfigOutcome describeLiveDelayConfig(const Model::DescribeLiveDelayConfigRequest &request)const;
+			void describeLiveDelayConfigAsync(const Model::DescribeLiveDelayConfigRequest& request, const DescribeLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveDelayConfigOutcomeCallable describeLiveDelayConfigCallable(const Model::DescribeLiveDelayConfigRequest& request) const;
 			DescribeLiveDelayedStreamingUsageOutcome describeLiveDelayedStreamingUsage(const Model::DescribeLiveDelayedStreamingUsageRequest &request)const;
 			void describeLiveDelayedStreamingUsageAsync(const Model::DescribeLiveDelayedStreamingUsageRequest& request, const DescribeLiveDelayedStreamingUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDelayedStreamingUsageOutcomeCallable describeLiveDelayedStreamingUsageCallable(const Model::DescribeLiveDelayedStreamingUsageRequest& request) const;
@@ -2006,6 +2053,9 @@ namespace AlibabaCloud
 			DescribeLiveRecordNotifyConfigOutcome describeLiveRecordNotifyConfig(const Model::DescribeLiveRecordNotifyConfigRequest &request)const;
 			void describeLiveRecordNotifyConfigAsync(const Model::DescribeLiveRecordNotifyConfigRequest& request, const DescribeLiveRecordNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveRecordNotifyConfigOutcomeCallable describeLiveRecordNotifyConfigCallable(const Model::DescribeLiveRecordNotifyConfigRequest& request) const;
+			DescribeLiveRecordNotifyRecordsOutcome describeLiveRecordNotifyRecords(const Model::DescribeLiveRecordNotifyRecordsRequest &request)const;
+			void describeLiveRecordNotifyRecordsAsync(const Model::DescribeLiveRecordNotifyRecordsRequest& request, const DescribeLiveRecordNotifyRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveRecordNotifyRecordsOutcomeCallable describeLiveRecordNotifyRecordsCallable(const Model::DescribeLiveRecordNotifyRecordsRequest& request) const;
 			DescribeLiveRecordVodConfigsOutcome describeLiveRecordVodConfigs(const Model::DescribeLiveRecordVodConfigsRequest &request)const;
 			void describeLiveRecordVodConfigsAsync(const Model::DescribeLiveRecordVodConfigsRequest& request, const DescribeLiveRecordVodConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveRecordVodConfigsOutcomeCallable describeLiveRecordVodConfigsCallable(const Model::DescribeLiveRecordVodConfigsRequest& request) const;
@@ -2222,6 +2272,9 @@ namespace AlibabaCloud
 			LeaveMessageGroupOutcome leaveMessageGroup(const Model::LeaveMessageGroupRequest &request)const;
 			void leaveMessageGroupAsync(const Model::LeaveMessageGroupRequest& request, const LeaveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			LeaveMessageGroupOutcomeCallable leaveMessageGroupCallable(const Model::LeaveMessageGroupRequest& request) const;
+			ListLiveDelayConfigOutcome listLiveDelayConfig(const Model::ListLiveDelayConfigRequest &request)const;
+			void listLiveDelayConfigAsync(const Model::ListLiveDelayConfigRequest& request, const ListLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListLiveDelayConfigOutcomeCallable listLiveDelayConfigCallable(const Model::ListLiveDelayConfigRequest& request) const;
 			ListLiveRealtimeLogDeliveryOutcome listLiveRealtimeLogDelivery(const Model::ListLiveRealtimeLogDeliveryRequest &request)const;
 			void listLiveRealtimeLogDeliveryAsync(const Model::ListLiveRealtimeLogDeliveryRequest& request, const ListLiveRealtimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListLiveRealtimeLogDeliveryOutcomeCallable listLiveRealtimeLogDeliveryCallable(const Model::ListLiveRealtimeLogDeliveryRequest& request) const;
@@ -2429,6 +2482,9 @@ namespace AlibabaCloud
 			UpdateLiveCenterTransferOutcome updateLiveCenterTransfer(const Model::UpdateLiveCenterTransferRequest &request)const;
 			void updateLiveCenterTransferAsync(const Model::UpdateLiveCenterTransferRequest& request, const UpdateLiveCenterTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateLiveCenterTransferOutcomeCallable updateLiveCenterTransferCallable(const Model::UpdateLiveCenterTransferRequest& request) const;
+			UpdateLiveDelayConfigOutcome updateLiveDelayConfig(const Model::UpdateLiveDelayConfigRequest &request)const;
+			void updateLiveDelayConfigAsync(const Model::UpdateLiveDelayConfigRequest& request, const UpdateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLiveDelayConfigOutcomeCallable updateLiveDelayConfigCallable(const Model::UpdateLiveDelayConfigRequest& request) const;
 			UpdateLiveDetectNotifyConfigOutcome updateLiveDetectNotifyConfig(const Model::UpdateLiveDetectNotifyConfigRequest &request)const;
 			void updateLiveDetectNotifyConfigAsync(const Model::UpdateLiveDetectNotifyConfigRequest& request, const UpdateLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateLiveDetectNotifyConfigOutcomeCallable updateLiveDetectNotifyConfigCallable(const Model::UpdateLiveDetectNotifyConfigRequest& request) const;

live/include/alibabacloud/live/model/BatchGetOnlineUsersRequest.h

@@ -0,0 +1,48 @@
+/*
+ * 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_BATCHGETONLINEUSERSREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT BatchGetOnlineUsersRequest : public RpcServiceRequest {
+public:
+	BatchGetOnlineUsersRequest();
+	~BatchGetOnlineUsersRequest();
+	std::string getGroupId() const;
+	void setGroupId(const std::string &groupId);
+	std::string getUserIds() const;
+	void setUserIds(const std::string &userIds);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+
+private:
+	std::string groupId_;
+	std::string userIds_;
+	std::string appId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSREQUEST_H_

live/include/alibabacloud/live/model/BatchGetOnlineUsersResult.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_BATCHGETONLINEUSERSRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSRESULT_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 BatchGetOnlineUsersResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					struct OnlineUsersItem
+					{
+						std::string userId;
+						long joinTime;
+						bool online;
+					};
+					std::vector<OnlineUsersItem> onlineUsers;
+				};
+
+
+				BatchGetOnlineUsersResult();
+				explicit BatchGetOnlineUsersResult(const std::string &payload);
+				~BatchGetOnlineUsersResult();
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_BATCHGETONLINEUSERSRESULT_H_

live/include/alibabacloud/live/model/CreateLiveDelayConfigRequest.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_CREATELIVEDELAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_CREATELIVEDELAYCONFIGREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT CreateLiveDelayConfigRequest : public RpcServiceRequest {
+public:
+	CreateLiveDelayConfigRequest();
+	~CreateLiveDelayConfigRequest();
+	int getDelayTime() const;
+	void setDelayTime(int delayTime);
+	std::string getStream() const;
+	void setStream(const std::string &stream);
+	std::string getApp() const;
+	void setApp(const std::string &app);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getTaskTriggerMode() const;
+	void setTaskTriggerMode(const std::string &taskTriggerMode);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+
+private:
+	int delayTime_;
+	std::string stream_;
+	std::string app_;
+	long ownerId_;
+	std::string taskTriggerMode_;
+	std::string domain_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_CREATELIVEDELAYCONFIGREQUEST_H_

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

live/include/alibabacloud/live/model/DeleteLiveDelayConfigRequest.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_DELETELIVEDELAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEDELAYCONFIGREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT DeleteLiveDelayConfigRequest : public RpcServiceRequest {
+public:
+	DeleteLiveDelayConfigRequest();
+	~DeleteLiveDelayConfigRequest();
+	std::string getStream() const;
+	void setStream(const std::string &stream);
+	std::string getApp() const;
+	void setApp(const std::string &app);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+
+private:
+	std::string stream_;
+	std::string app_;
+	long ownerId_;
+	std::string domain_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEDELAYCONFIGREQUEST_H_

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

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

@@ -49,6 +49,7 @@ namespace AlibabaCloud
 					std::string ossEndpoint;
 					std::vector<RecordFormatItem> recordFormat;
 					std::string ossBucket;
+					int onDemand;
 				};
 				struct SyncGroup
 				{

live/include/alibabacloud/live/model/DescribeLiveDelayConfigRequest.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_DESCRIBELIVEDELAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDelayConfigRequest : public RpcServiceRequest {
+public:
+	DescribeLiveDelayConfigRequest();
+	~DescribeLiveDelayConfigRequest();
+	std::string getStream() const;
+	void setStream(const std::string &stream);
+	std::string getApp() const;
+	void setApp(const std::string &app);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+
+private:
+	std::string stream_;
+	std::string app_;
+	long ownerId_;
+	std::string domain_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDelayConfigResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_DESCRIBELIVEDELAYCONFIGRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGRESULT_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 DescribeLiveDelayConfigResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeLiveDelayConfigResult();
+				explicit DescribeLiveDelayConfigResult(const std::string &payload);
+				~DescribeLiveDelayConfigResult();
+				std::string getApp()const;
+				std::string getTaskTriggerMode()const;
+				std::string getStream()const;
+				std::string getDomain()const;
+				std::string getDelayTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string app_;
+				std::string taskTriggerMode_;
+				std::string stream_;
+				std::string domain_;
+				std::string delayTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYCONFIGRESULT_H_

live/include/alibabacloud/live/model/DescribeLiveDomainRecordUsageDataRequest.h

@@ -42,6 +42,8 @@ public:
 	void setOwnerId(long ownerId);
 	std::string getInterval() const;
 	void setInterval(const std::string &interval);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
 
 private:
 	std::string startTime_;
@@ -50,6 +52,7 @@ private:
 	std::string endTime_;
 	long ownerId_;
 	std::string interval_;
+	std::string region_;
 };
 } // namespace Model
 } // namespace Live

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

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

live/include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsRequest.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_DESCRIBELIVERECORDNOTIFYRECORDSREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT DescribeLiveRecordNotifyRecordsRequest : public RpcServiceRequest {
+public:
+	DescribeLiveRecordNotifyRecordsRequest();
+	~DescribeLiveRecordNotifyRecordsRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string startTime_;
+	long pageNumber_;
+	std::string appName_;
+	long pageSize_;
+	std::string streamName_;
+	std::string domainName_;
+	std::string endTime_;
+	long ownerId_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveRecordNotifyRecordsResult.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSRESULT_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 DescribeLiveRecordNotifyRecordsResult : public ServiceResult
+			{
+			public:
+				struct Callback
+				{
+					std::string notifyType;
+					std::string description;
+					std::string streamName;
+					std::string notifyTime;
+					std::string notifyContent;
+					std::string domainName;
+					std::string notifyUrl;
+					std::string notifyResult;
+					std::string appName;
+				};
+
+
+				DescribeLiveRecordNotifyRecordsResult();
+				explicit DescribeLiveRecordNotifyRecordsResult(const std::string &payload);
+				~DescribeLiveRecordNotifyRecordsResult();
+				std::string getMsg()const;
+				int getTotalNum()const;
+				std::vector<Callback> getCallbackList()const;
+				int getPageNum()const;
+				int getTotalPage()const;
+				int getPageSize()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string msg_;
+				int totalNum_;
+				std::vector<Callback> callbackList_;
+				int pageNum_;
+				int totalPage_;
+				int pageSize_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVERECORDNOTIFYRECORDSRESULT_H_

live/include/alibabacloud/live/model/ListLiveDelayConfigRequest.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_LISTLIVEDELAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT ListLiveDelayConfigRequest : public RpcServiceRequest {
+public:
+	ListLiveDelayConfigRequest();
+	~ListLiveDelayConfigRequest();
+	int getPageNum() const;
+	void setPageNum(int pageNum);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+
+private:
+	int pageNum_;
+	int pageSize_;
+	long ownerId_;
+	std::string domain_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGREQUEST_H_

live/include/alibabacloud/live/model/ListLiveDelayConfigResult.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_LISTLIVEDELAYCONFIGRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGRESULT_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 ListLiveDelayConfigResult : public ServiceResult
+			{
+			public:
+				struct DelayConfig
+				{
+					std::string app;
+					std::string taskTriggerMode;
+					std::string stream;
+					std::string domain;
+					std::string delayTime;
+				};
+
+
+				ListLiveDelayConfigResult();
+				explicit ListLiveDelayConfigResult(const std::string &payload);
+				~ListLiveDelayConfigResult();
+				std::vector<DelayConfig> getDelayConfigList()const;
+				int getTotal()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DelayConfig> delayConfigList_;
+				int total_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_LISTLIVEDELAYCONFIGRESULT_H_

live/include/alibabacloud/live/model/UpdateCasterSceneAudioRequest.h

@@ -32,6 +32,7 @@ public:
 		float volumeRate;
 		int fixedDelayDuration;
 		std::string validChannel;
+		std::string filter;
 	};
 	UpdateCasterSceneAudioRequest();
 	~UpdateCasterSceneAudioRequest();

live/include/alibabacloud/live/model/UpdateLiveDelayConfigRequest.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_UPDATELIVEDELAYCONFIGREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_UPDATELIVEDELAYCONFIGREQUEST_H_
+
+#include <alibabacloud/live/LiveExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Live {
+namespace Model {
+class ALIBABACLOUD_LIVE_EXPORT UpdateLiveDelayConfigRequest : public RpcServiceRequest {
+public:
+	UpdateLiveDelayConfigRequest();
+	~UpdateLiveDelayConfigRequest();
+	int getDelayTime() const;
+	void setDelayTime(int delayTime);
+	std::string getStream() const;
+	void setStream(const std::string &stream);
+	std::string getApp() const;
+	void setApp(const std::string &app);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getTaskTriggerMode() const;
+	void setTaskTriggerMode(const std::string &taskTriggerMode);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+
+private:
+	int delayTime_;
+	std::string stream_;
+	std::string app_;
+	long ownerId_;
+	std::string taskTriggerMode_;
+	std::string domain_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_UPDATELIVEDELAYCONFIGREQUEST_H_

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

live/src/LiveClient.cc

@@ -1239,6 +1239,42 @@ LiveClient::BatchDeleteLiveDomainConfigsOutcomeCallable LiveClient::batchDeleteL
 	return task->get_future();
 }
 
+LiveClient::BatchGetOnlineUsersOutcome LiveClient::batchGetOnlineUsers(const BatchGetOnlineUsersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BatchGetOnlineUsersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BatchGetOnlineUsersOutcome(BatchGetOnlineUsersResult(outcome.result()));
+	else
+		return BatchGetOnlineUsersOutcome(outcome.error());
+}
+
+void LiveClient::batchGetOnlineUsersAsync(const BatchGetOnlineUsersRequest& request, const BatchGetOnlineUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, batchGetOnlineUsers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::BatchGetOnlineUsersOutcomeCallable LiveClient::batchGetOnlineUsersCallable(const BatchGetOnlineUsersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BatchGetOnlineUsersOutcome()>>(
+			[this, request]()
+			{
+			return this->batchGetOnlineUsers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::BatchSetLiveDomainConfigsOutcome LiveClient::batchSetLiveDomainConfigs(const BatchSetLiveDomainConfigsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1527,6 +1563,42 @@ LiveClient::CreateCustomTemplateOutcomeCallable LiveClient::createCustomTemplate
 	return task->get_future();
 }
 
+LiveClient::CreateLiveDelayConfigOutcome LiveClient::createLiveDelayConfig(const CreateLiveDelayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLiveDelayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLiveDelayConfigOutcome(CreateLiveDelayConfigResult(outcome.result()));
+	else
+		return CreateLiveDelayConfigOutcome(outcome.error());
+}
+
+void LiveClient::createLiveDelayConfigAsync(const CreateLiveDelayConfigRequest& request, const CreateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLiveDelayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::CreateLiveDelayConfigOutcomeCallable LiveClient::createLiveDelayConfigCallable(const CreateLiveDelayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLiveDelayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->createLiveDelayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::CreateLiveRealTimeLogDeliveryOutcome LiveClient::createLiveRealTimeLogDelivery(const CreateLiveRealTimeLogDeliveryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2355,42 @@ LiveClient::DeleteLiveCenterTransferOutcomeCallable LiveClient::deleteLiveCenter
 	return task->get_future();
 }
 
+LiveClient::DeleteLiveDelayConfigOutcome LiveClient::deleteLiveDelayConfig(const DeleteLiveDelayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteLiveDelayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteLiveDelayConfigOutcome(DeleteLiveDelayConfigResult(outcome.result()));
+	else
+		return DeleteLiveDelayConfigOutcome(outcome.error());
+}
+
+void LiveClient::deleteLiveDelayConfigAsync(const DeleteLiveDelayConfigRequest& request, const DeleteLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteLiveDelayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DeleteLiveDelayConfigOutcomeCallable LiveClient::deleteLiveDelayConfigCallable(const DeleteLiveDelayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteLiveDelayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteLiveDelayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DeleteLiveDetectNotifyConfigOutcome LiveClient::deleteLiveDetectNotifyConfig(const DeleteLiveDetectNotifyConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4083,6 +4191,42 @@ LiveClient::DescribeLiveCertificateListOutcomeCallable LiveClient::describeLiveC
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDelayConfigOutcome LiveClient::describeLiveDelayConfig(const DescribeLiveDelayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDelayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDelayConfigOutcome(DescribeLiveDelayConfigResult(outcome.result()));
+	else
+		return DescribeLiveDelayConfigOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDelayConfigAsync(const DescribeLiveDelayConfigRequest& request, const DescribeLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDelayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDelayConfigOutcomeCallable LiveClient::describeLiveDelayConfigCallable(const DescribeLiveDelayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDelayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDelayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDelayedStreamingUsageOutcome LiveClient::describeLiveDelayedStreamingUsage(const DescribeLiveDelayedStreamingUsageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5451,6 +5595,42 @@ LiveClient::DescribeLiveRecordNotifyConfigOutcomeCallable LiveClient::describeLi
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveRecordNotifyRecordsOutcome LiveClient::describeLiveRecordNotifyRecords(const DescribeLiveRecordNotifyRecordsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveRecordNotifyRecordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveRecordNotifyRecordsOutcome(DescribeLiveRecordNotifyRecordsResult(outcome.result()));
+	else
+		return DescribeLiveRecordNotifyRecordsOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveRecordNotifyRecordsAsync(const DescribeLiveRecordNotifyRecordsRequest& request, const DescribeLiveRecordNotifyRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveRecordNotifyRecords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveRecordNotifyRecordsOutcomeCallable LiveClient::describeLiveRecordNotifyRecordsCallable(const DescribeLiveRecordNotifyRecordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveRecordNotifyRecordsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveRecordNotifyRecords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveRecordVodConfigsOutcome LiveClient::describeLiveRecordVodConfigs(const DescribeLiveRecordVodConfigsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8043,6 +8223,42 @@ LiveClient::LeaveMessageGroupOutcomeCallable LiveClient::leaveMessageGroupCallab
 	return task->get_future();
 }
 
+LiveClient::ListLiveDelayConfigOutcome LiveClient::listLiveDelayConfig(const ListLiveDelayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListLiveDelayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListLiveDelayConfigOutcome(ListLiveDelayConfigResult(outcome.result()));
+	else
+		return ListLiveDelayConfigOutcome(outcome.error());
+}
+
+void LiveClient::listLiveDelayConfigAsync(const ListLiveDelayConfigRequest& request, const ListLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listLiveDelayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::ListLiveDelayConfigOutcomeCallable LiveClient::listLiveDelayConfigCallable(const ListLiveDelayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListLiveDelayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->listLiveDelayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::ListLiveRealtimeLogDeliveryOutcome LiveClient::listLiveRealtimeLogDelivery(const ListLiveRealtimeLogDeliveryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -10527,6 +10743,42 @@ LiveClient::UpdateLiveCenterTransferOutcomeCallable LiveClient::updateLiveCenter
 	return task->get_future();
 }
 
+LiveClient::UpdateLiveDelayConfigOutcome LiveClient::updateLiveDelayConfig(const UpdateLiveDelayConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLiveDelayConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLiveDelayConfigOutcome(UpdateLiveDelayConfigResult(outcome.result()));
+	else
+		return UpdateLiveDelayConfigOutcome(outcome.error());
+}
+
+void LiveClient::updateLiveDelayConfigAsync(const UpdateLiveDelayConfigRequest& request, const UpdateLiveDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLiveDelayConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::UpdateLiveDelayConfigOutcomeCallable LiveClient::updateLiveDelayConfigCallable(const UpdateLiveDelayConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLiveDelayConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLiveDelayConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::UpdateLiveDetectNotifyConfigOutcome LiveClient::updateLiveDetectNotifyConfig(const UpdateLiveDetectNotifyConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/BatchGetOnlineUsersRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/live/model/BatchGetOnlineUsersRequest.h>
+
+using AlibabaCloud::Live::Model::BatchGetOnlineUsersRequest;
+
+BatchGetOnlineUsersRequest::BatchGetOnlineUsersRequest()
+    : RpcServiceRequest("live", "2016-11-01", "BatchGetOnlineUsers") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BatchGetOnlineUsersRequest::~BatchGetOnlineUsersRequest() {}
+
+std::string BatchGetOnlineUsersRequest::getGroupId() const {
+  return groupId_;
+}
+
+void BatchGetOnlineUsersRequest::setGroupId(const std::string &groupId) {
+  groupId_ = groupId;
+  setBodyParameter(std::string("GroupId"), groupId);
+}
+
+std::string BatchGetOnlineUsersRequest::getUserIds() const {
+  return userIds_;
+}
+
+void BatchGetOnlineUsersRequest::setUserIds(const std::string &userIds) {
+  userIds_ = userIds;
+  setBodyParameter(std::string("UserIds"), userIds);
+}
+
+std::string BatchGetOnlineUsersRequest::getAppId() const {
+  return appId_;
+}
+
+void BatchGetOnlineUsersRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setBodyParameter(std::string("AppId"), appId);
+}
+

live/src/model/BatchGetOnlineUsersResult.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/BatchGetOnlineUsersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+BatchGetOnlineUsersResult::BatchGetOnlineUsersResult() :
+	ServiceResult()
+{}
+
+BatchGetOnlineUsersResult::BatchGetOnlineUsersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BatchGetOnlineUsersResult::~BatchGetOnlineUsersResult()
+{}
+
+void BatchGetOnlineUsersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	auto allOnlineUsersNode = resultNode["OnlineUsers"]["onlineUsersItem"];
+	for (auto resultNodeOnlineUsersonlineUsersItem : allOnlineUsersNode)
+	{
+		Result::OnlineUsersItem onlineUsersItemObject;
+		if(!resultNodeOnlineUsersonlineUsersItem["UserId"].isNull())
+			onlineUsersItemObject.userId = resultNodeOnlineUsersonlineUsersItem["UserId"].asString();
+		if(!resultNodeOnlineUsersonlineUsersItem["JoinTime"].isNull())
+			onlineUsersItemObject.joinTime = std::stol(resultNodeOnlineUsersonlineUsersItem["JoinTime"].asString());
+		if(!resultNodeOnlineUsersonlineUsersItem["Online"].isNull())
+			onlineUsersItemObject.online = resultNodeOnlineUsersonlineUsersItem["Online"].asString() == "true";
+		result_.onlineUsers.push_back(onlineUsersItemObject);
+	}
+
+}
+
+BatchGetOnlineUsersResult::Result BatchGetOnlineUsersResult::getResult()const
+{
+	return result_;
+}
+

live/src/model/CreateLiveDelayConfigRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/CreateLiveDelayConfigRequest.h>
+
+using AlibabaCloud::Live::Model::CreateLiveDelayConfigRequest;
+
+CreateLiveDelayConfigRequest::CreateLiveDelayConfigRequest()
+    : RpcServiceRequest("live", "2016-11-01", "CreateLiveDelayConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLiveDelayConfigRequest::~CreateLiveDelayConfigRequest() {}
+
+int CreateLiveDelayConfigRequest::getDelayTime() const {
+  return delayTime_;
+}
+
+void CreateLiveDelayConfigRequest::setDelayTime(int delayTime) {
+  delayTime_ = delayTime;
+  setParameter(std::string("DelayTime"), std::to_string(delayTime));
+}
+
+std::string CreateLiveDelayConfigRequest::getStream() const {
+  return stream_;
+}
+
+void CreateLiveDelayConfigRequest::setStream(const std::string &stream) {
+  stream_ = stream;
+  setParameter(std::string("Stream"), stream);
+}
+
+std::string CreateLiveDelayConfigRequest::getApp() const {
+  return app_;
+}
+
+void CreateLiveDelayConfigRequest::setApp(const std::string &app) {
+  app_ = app;
+  setParameter(std::string("App"), app);
+}
+
+long CreateLiveDelayConfigRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLiveDelayConfigRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLiveDelayConfigRequest::getTaskTriggerMode() const {
+  return taskTriggerMode_;
+}
+
+void CreateLiveDelayConfigRequest::setTaskTriggerMode(const std::string &taskTriggerMode) {
+  taskTriggerMode_ = taskTriggerMode;
+  setParameter(std::string("TaskTriggerMode"), taskTriggerMode);
+}
+
+std::string CreateLiveDelayConfigRequest::getDomain() const {
+  return domain_;
+}
+
+void CreateLiveDelayConfigRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

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

live/src/model/DeleteLiveDelayConfigRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/DeleteLiveDelayConfigRequest.h>
+
+using AlibabaCloud::Live::Model::DeleteLiveDelayConfigRequest;
+
+DeleteLiveDelayConfigRequest::DeleteLiveDelayConfigRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DeleteLiveDelayConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteLiveDelayConfigRequest::~DeleteLiveDelayConfigRequest() {}
+
+std::string DeleteLiveDelayConfigRequest::getStream() const {
+  return stream_;
+}
+
+void DeleteLiveDelayConfigRequest::setStream(const std::string &stream) {
+  stream_ = stream;
+  setParameter(std::string("Stream"), stream);
+}
+
+std::string DeleteLiveDelayConfigRequest::getApp() const {
+  return app_;
+}
+
+void DeleteLiveDelayConfigRequest::setApp(const std::string &app) {
+  app_ = app;
+  setParameter(std::string("App"), app);
+}
+
+long DeleteLiveDelayConfigRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteLiveDelayConfigRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteLiveDelayConfigRequest::getDomain() const {
+  return domain_;
+}
+
+void DeleteLiveDelayConfigRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

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

live/src/model/DescribeCasterConfigResult.cc

@@ -63,6 +63,8 @@ void DescribeCasterConfigResult::parse(const std::string &payload)
 		recordConfig_.ossEndpoint = recordConfigNode["OssEndpoint"].asString();
 	if(!recordConfigNode["OssBucket"].isNull())
 		recordConfig_.ossBucket = recordConfigNode["OssBucket"].asString();
+	if(!recordConfigNode["OnDemand"].isNull())
+		recordConfig_.onDemand = std::stoi(recordConfigNode["OnDemand"].asString());
 	auto allRecordFormatNode = recordConfigNode["RecordFormat"]["RecordFormatItem"];
 	for (auto recordConfigNodeRecordFormatRecordFormatItem : allRecordFormatNode)
 	{

live/src/model/DescribeLiveDelayConfigRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDelayConfigRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveDelayConfigRequest;
+
+DescribeLiveDelayConfigRequest::DescribeLiveDelayConfigRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLiveDelayConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveDelayConfigRequest::~DescribeLiveDelayConfigRequest() {}
+
+std::string DescribeLiveDelayConfigRequest::getStream() const {
+  return stream_;
+}
+
+void DescribeLiveDelayConfigRequest::setStream(const std::string &stream) {
+  stream_ = stream;
+  setParameter(std::string("Stream"), stream);
+}
+
+std::string DescribeLiveDelayConfigRequest::getApp() const {
+  return app_;
+}
+
+void DescribeLiveDelayConfigRequest::setApp(const std::string &app) {
+  app_ = app;
+  setParameter(std::string("App"), app);
+}
+
+long DescribeLiveDelayConfigRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLiveDelayConfigRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeLiveDelayConfigRequest::getDomain() const {
+  return domain_;
+}
+
+void DescribeLiveDelayConfigRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

live/src/model/DescribeLiveDelayConfigResult.cc

@@ -0,0 +1,79 @@
+/*
+ * 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/DescribeLiveDelayConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDelayConfigResult::DescribeLiveDelayConfigResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDelayConfigResult::DescribeLiveDelayConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDelayConfigResult::~DescribeLiveDelayConfigResult()
+{}
+
+void DescribeLiveDelayConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Domain"].isNull())
+		domain_ = value["Domain"].asString();
+	if(!value["TaskTriggerMode"].isNull())
+		taskTriggerMode_ = value["TaskTriggerMode"].asString();
+	if(!value["App"].isNull())
+		app_ = value["App"].asString();
+	if(!value["DelayTime"].isNull())
+		delayTime_ = value["DelayTime"].asString();
+	if(!value["Stream"].isNull())
+		stream_ = value["Stream"].asString();
+
+}
+
+std::string DescribeLiveDelayConfigResult::getApp()const
+{
+	return app_;
+}
+
+std::string DescribeLiveDelayConfigResult::getTaskTriggerMode()const
+{
+	return taskTriggerMode_;
+}
+
+std::string DescribeLiveDelayConfigResult::getStream()const
+{
+	return stream_;
+}
+
+std::string DescribeLiveDelayConfigResult::getDomain()const
+{
+	return domain_;
+}
+
+std::string DescribeLiveDelayConfigResult::getDelayTime()const
+{
+	return delayTime_;
+}
+

live/src/model/DescribeLiveDomainRecordUsageDataRequest.cc

@@ -79,3 +79,12 @@ void DescribeLiveDomainRecordUsageDataRequest::setInterval(const std::string &in
   setParameter(std::string("Interval"), interval);
 }
 
+std::string DescribeLiveDomainRecordUsageDataRequest::getRegion() const {
+  return region_;
+}
+
+void DescribeLiveDomainRecordUsageDataRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

live/src/model/DescribeLiveDomainRecordUsageDataResult.cc

@@ -45,12 +45,14 @@ void DescribeLiveDomainRecordUsageDataResult::parse(const std::string &payload)
 		DataModule recordUsageDataObject;
 		if(!valueRecordUsageDataDataModule["Type"].isNull())
 			recordUsageDataObject.type = valueRecordUsageDataDataModule["Type"].asString();
-		if(!valueRecordUsageDataDataModule["Duration"].isNull())
-			recordUsageDataObject.duration = std::stol(valueRecordUsageDataDataModule["Duration"].asString());
 		if(!valueRecordUsageDataDataModule["Domain"].isNull())
 			recordUsageDataObject.domain = valueRecordUsageDataDataModule["Domain"].asString();
+		if(!valueRecordUsageDataDataModule["Region"].isNull())
+			recordUsageDataObject.region = valueRecordUsageDataDataModule["Region"].asString();
 		if(!valueRecordUsageDataDataModule["TimeStamp"].isNull())
 			recordUsageDataObject.timeStamp = valueRecordUsageDataDataModule["TimeStamp"].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/DescribeLiveRecordNotifyRecordsRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/DescribeLiveRecordNotifyRecordsRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLiveRecordNotifyRecordsRequest;
+
+DescribeLiveRecordNotifyRecordsRequest::DescribeLiveRecordNotifyRecordsRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLiveRecordNotifyRecords") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLiveRecordNotifyRecordsRequest::~DescribeLiveRecordNotifyRecordsRequest() {}
+
+std::string DescribeLiveRecordNotifyRecordsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+long DescribeLiveRecordNotifyRecordsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeLiveRecordNotifyRecordsRequest::getAppName() const {
+  return appName_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setAppName(const std::string &appName) {
+  appName_ = appName;
+  setParameter(std::string("AppName"), appName);
+}
+
+long DescribeLiveRecordNotifyRecordsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeLiveRecordNotifyRecordsRequest::getStreamName() const {
+  return streamName_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setStreamName(const std::string &streamName) {
+  streamName_ = streamName;
+  setParameter(std::string("StreamName"), streamName);
+}
+
+std::string DescribeLiveRecordNotifyRecordsRequest::getDomainName() const {
+  return domainName_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+std::string DescribeLiveRecordNotifyRecordsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+long DescribeLiveRecordNotifyRecordsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeLiveRecordNotifyRecordsRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeLiveRecordNotifyRecordsRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+

live/src/model/DescribeLiveRecordNotifyRecordsResult.cc

@@ -0,0 +1,115 @@
+/*
+ * 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/DescribeLiveRecordNotifyRecordsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveRecordNotifyRecordsResult::DescribeLiveRecordNotifyRecordsResult() :
+	ServiceResult()
+{}
+
+DescribeLiveRecordNotifyRecordsResult::DescribeLiveRecordNotifyRecordsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveRecordNotifyRecordsResult::~DescribeLiveRecordNotifyRecordsResult()
+{}
+
+void DescribeLiveRecordNotifyRecordsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCallbackListNode = value["CallbackList"]["Callback"];
+	for (auto valueCallbackListCallback : allCallbackListNode)
+	{
+		Callback callbackListObject;
+		if(!valueCallbackListCallback["AppName"].isNull())
+			callbackListObject.appName = valueCallbackListCallback["AppName"].asString();
+		if(!valueCallbackListCallback["NotifyType"].isNull())
+			callbackListObject.notifyType = valueCallbackListCallback["NotifyType"].asString();
+		if(!valueCallbackListCallback["NotifyContent"].isNull())
+			callbackListObject.notifyContent = valueCallbackListCallback["NotifyContent"].asString();
+		if(!valueCallbackListCallback["Description"].isNull())
+			callbackListObject.description = valueCallbackListCallback["Description"].asString();
+		if(!valueCallbackListCallback["StreamName"].isNull())
+			callbackListObject.streamName = valueCallbackListCallback["StreamName"].asString();
+		if(!valueCallbackListCallback["NotifyUrl"].isNull())
+			callbackListObject.notifyUrl = valueCallbackListCallback["NotifyUrl"].asString();
+		if(!valueCallbackListCallback["NotifyResult"].isNull())
+			callbackListObject.notifyResult = valueCallbackListCallback["NotifyResult"].asString();
+		if(!valueCallbackListCallback["NotifyTime"].isNull())
+			callbackListObject.notifyTime = valueCallbackListCallback["NotifyTime"].asString();
+		if(!valueCallbackListCallback["DomainName"].isNull())
+			callbackListObject.domainName = valueCallbackListCallback["DomainName"].asString();
+		callbackList_.push_back(callbackListObject);
+	}
+	if(!value["Msg"].isNull())
+		msg_ = value["Msg"].asString();
+	if(!value["PageNum"].isNull())
+		pageNum_ = std::stoi(value["PageNum"].asString());
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["TotalPage"].isNull())
+		totalPage_ = std::stoi(value["TotalPage"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalNum"].isNull())
+		totalNum_ = std::stoi(value["TotalNum"].asString());
+
+}
+
+std::string DescribeLiveRecordNotifyRecordsResult::getMsg()const
+{
+	return msg_;
+}
+
+int DescribeLiveRecordNotifyRecordsResult::getTotalNum()const
+{
+	return totalNum_;
+}
+
+std::vector<DescribeLiveRecordNotifyRecordsResult::Callback> DescribeLiveRecordNotifyRecordsResult::getCallbackList()const
+{
+	return callbackList_;
+}
+
+int DescribeLiveRecordNotifyRecordsResult::getPageNum()const
+{
+	return pageNum_;
+}
+
+int DescribeLiveRecordNotifyRecordsResult::getTotalPage()const
+{
+	return totalPage_;
+}
+
+int DescribeLiveRecordNotifyRecordsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeLiveRecordNotifyRecordsResult::getCode()const
+{
+	return code_;
+}
+

live/src/model/ListLiveDelayConfigRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/ListLiveDelayConfigRequest.h>
+
+using AlibabaCloud::Live::Model::ListLiveDelayConfigRequest;
+
+ListLiveDelayConfigRequest::ListLiveDelayConfigRequest()
+    : RpcServiceRequest("live", "2016-11-01", "ListLiveDelayConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListLiveDelayConfigRequest::~ListLiveDelayConfigRequest() {}
+
+int ListLiveDelayConfigRequest::getPageNum() const {
+  return pageNum_;
+}
+
+void ListLiveDelayConfigRequest::setPageNum(int pageNum) {
+  pageNum_ = pageNum;
+  setParameter(std::string("PageNum"), std::to_string(pageNum));
+}
+
+int ListLiveDelayConfigRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListLiveDelayConfigRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+long ListLiveDelayConfigRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ListLiveDelayConfigRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string ListLiveDelayConfigRequest::getDomain() const {
+  return domain_;
+}
+
+void ListLiveDelayConfigRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

live/src/model/ListLiveDelayConfigResult.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/ListLiveDelayConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+ListLiveDelayConfigResult::ListLiveDelayConfigResult() :
+	ServiceResult()
+{}
+
+ListLiveDelayConfigResult::ListLiveDelayConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListLiveDelayConfigResult::~ListLiveDelayConfigResult()
+{}
+
+void ListLiveDelayConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDelayConfigListNode = value["DelayConfigList"]["DelayConfig"];
+	for (auto valueDelayConfigListDelayConfig : allDelayConfigListNode)
+	{
+		DelayConfig delayConfigListObject;
+		if(!valueDelayConfigListDelayConfig["Stream"].isNull())
+			delayConfigListObject.stream = valueDelayConfigListDelayConfig["Stream"].asString();
+		if(!valueDelayConfigListDelayConfig["Domain"].isNull())
+			delayConfigListObject.domain = valueDelayConfigListDelayConfig["Domain"].asString();
+		if(!valueDelayConfigListDelayConfig["TaskTriggerMode"].isNull())
+			delayConfigListObject.taskTriggerMode = valueDelayConfigListDelayConfig["TaskTriggerMode"].asString();
+		if(!valueDelayConfigListDelayConfig["DelayTime"].isNull())
+			delayConfigListObject.delayTime = valueDelayConfigListDelayConfig["DelayTime"].asString();
+		if(!valueDelayConfigListDelayConfig["App"].isNull())
+			delayConfigListObject.app = valueDelayConfigListDelayConfig["App"].asString();
+		delayConfigList_.push_back(delayConfigListObject);
+	}
+	if(!value["Total"].isNull())
+		total_ = std::stoi(value["Total"].asString());
+
+}
+
+std::vector<ListLiveDelayConfigResult::DelayConfig> ListLiveDelayConfigResult::getDelayConfigList()const
+{
+	return delayConfigList_;
+}
+
+int ListLiveDelayConfigResult::getTotal()const
+{
+	return total_;
+}
+

live/src/model/UpdateCasterSceneAudioRequest.cc

@@ -55,6 +55,7 @@ void UpdateCasterSceneAudioRequest::setAudioLayer(const std::vector<UpdateCaster
     setParameter(audioLayerObjStr + ".VolumeRate", std::to_string(audioLayerObj.volumeRate));
     setParameter(audioLayerObjStr + ".FixedDelayDuration", std::to_string(audioLayerObj.fixedDelayDuration));
     setParameter(audioLayerObjStr + ".ValidChannel", audioLayerObj.validChannel);
+    setParameter(audioLayerObjStr + ".Filter", audioLayerObj.filter);
   }
 }
 

live/src/model/UpdateLiveDelayConfigRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/UpdateLiveDelayConfigRequest.h>
+
+using AlibabaCloud::Live::Model::UpdateLiveDelayConfigRequest;
+
+UpdateLiveDelayConfigRequest::UpdateLiveDelayConfigRequest()
+    : RpcServiceRequest("live", "2016-11-01", "UpdateLiveDelayConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateLiveDelayConfigRequest::~UpdateLiveDelayConfigRequest() {}
+
+int UpdateLiveDelayConfigRequest::getDelayTime() const {
+  return delayTime_;
+}
+
+void UpdateLiveDelayConfigRequest::setDelayTime(int delayTime) {
+  delayTime_ = delayTime;
+  setParameter(std::string("DelayTime"), std::to_string(delayTime));
+}
+
+std::string UpdateLiveDelayConfigRequest::getStream() const {
+  return stream_;
+}
+
+void UpdateLiveDelayConfigRequest::setStream(const std::string &stream) {
+  stream_ = stream;
+  setParameter(std::string("Stream"), stream);
+}
+
+std::string UpdateLiveDelayConfigRequest::getApp() const {
+  return app_;
+}
+
+void UpdateLiveDelayConfigRequest::setApp(const std::string &app) {
+  app_ = app;
+  setParameter(std::string("App"), app);
+}
+
+long UpdateLiveDelayConfigRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void UpdateLiveDelayConfigRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string UpdateLiveDelayConfigRequest::getTaskTriggerMode() const {
+  return taskTriggerMode_;
+}
+
+void UpdateLiveDelayConfigRequest::setTaskTriggerMode(const std::string &taskTriggerMode) {
+  taskTriggerMode_ = taskTriggerMode;
+  setParameter(std::string("TaskTriggerMode"), taskTriggerMode);
+}
+
+std::string UpdateLiveDelayConfigRequest::getDomain() const {
+  return domain_;
+}
+
+void UpdateLiveDelayConfigRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

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