Live sdk update.

VERSION

@@ -1 +1 @@
-1.36.1442
+1.36.1443

live/CMakeLists.txt

@@ -245,6 +245,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/DescribeLiveDelayedStreamingUsageRequest.h
+	include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageResult.h
 	include/alibabacloud/live/model/DescribeLiveDetectNotifyConfigRequest.h
 	include/alibabacloud/live/model/DescribeLiveDetectNotifyConfigResult.h
 	include/alibabacloud/live/model/DescribeLiveDetectPornDataRequest.h
@@ -555,6 +557,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/SetLiveEdgeTransferResult.h
 	include/alibabacloud/live/model/SetLiveLazyPullStreamInfoConfigRequest.h
 	include/alibabacloud/live/model/SetLiveLazyPullStreamInfoConfigResult.h
+	include/alibabacloud/live/model/SetLiveMpuTaskSeiRequest.h
+	include/alibabacloud/live/model/SetLiveMpuTaskSeiResult.h
 	include/alibabacloud/live/model/SetLiveStreamDelayConfigRequest.h
 	include/alibabacloud/live/model/SetLiveStreamDelayConfigResult.h
 	include/alibabacloud/live/model/SetLiveStreamOptimizedFeatureConfigRequest.h
@@ -852,6 +856,8 @@ set(live_src
 	src/model/DescribeLiveCertificateDetailResult.cc
 	src/model/DescribeLiveCertificateListRequest.cc
 	src/model/DescribeLiveCertificateListResult.cc
+	src/model/DescribeLiveDelayedStreamingUsageRequest.cc
+	src/model/DescribeLiveDelayedStreamingUsageResult.cc
 	src/model/DescribeLiveDetectNotifyConfigRequest.cc
 	src/model/DescribeLiveDetectNotifyConfigResult.cc
 	src/model/DescribeLiveDetectPornDataRequest.cc
@@ -1162,6 +1168,8 @@ set(live_src
 	src/model/SetLiveEdgeTransferResult.cc
 	src/model/SetLiveLazyPullStreamInfoConfigRequest.cc
 	src/model/SetLiveLazyPullStreamInfoConfigResult.cc
+	src/model/SetLiveMpuTaskSeiRequest.cc
+	src/model/SetLiveMpuTaskSeiResult.cc
 	src/model/SetLiveStreamDelayConfigRequest.cc
 	src/model/SetLiveStreamDelayConfigResult.cc
 	src/model/SetLiveStreamOptimizedFeatureConfigRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -246,6 +246,8 @@
 #include "model/DescribeLiveCertificateDetailResult.h"
 #include "model/DescribeLiveCertificateListRequest.h"
 #include "model/DescribeLiveCertificateListResult.h"
+#include "model/DescribeLiveDelayedStreamingUsageRequest.h"
+#include "model/DescribeLiveDelayedStreamingUsageResult.h"
 #include "model/DescribeLiveDetectNotifyConfigRequest.h"
 #include "model/DescribeLiveDetectNotifyConfigResult.h"
 #include "model/DescribeLiveDetectPornDataRequest.h"
@@ -556,6 +558,8 @@
 #include "model/SetLiveEdgeTransferResult.h"
 #include "model/SetLiveLazyPullStreamInfoConfigRequest.h"
 #include "model/SetLiveLazyPullStreamInfoConfigResult.h"
+#include "model/SetLiveMpuTaskSeiRequest.h"
+#include "model/SetLiveMpuTaskSeiResult.h"
 #include "model/SetLiveStreamDelayConfigRequest.h"
 #include "model/SetLiveStreamDelayConfigResult.h"
 #include "model/SetLiveStreamOptimizedFeatureConfigRequest.h"
@@ -971,6 +975,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::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;
 			typedef Outcome<Error, Model::DescribeLiveDetectNotifyConfigResult> DescribeLiveDetectNotifyConfigOutcome;
 			typedef std::future<DescribeLiveDetectNotifyConfigOutcome> DescribeLiveDetectNotifyConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveDetectNotifyConfigRequest&, const DescribeLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDetectNotifyConfigAsyncHandler;
@@ -1436,6 +1443,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetLiveLazyPullStreamInfoConfigResult> SetLiveLazyPullStreamInfoConfigOutcome;
 			typedef std::future<SetLiveLazyPullStreamInfoConfigOutcome> SetLiveLazyPullStreamInfoConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::SetLiveLazyPullStreamInfoConfigRequest&, const SetLiveLazyPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveLazyPullStreamInfoConfigAsyncHandler;
+			typedef Outcome<Error, Model::SetLiveMpuTaskSeiResult> SetLiveMpuTaskSeiOutcome;
+			typedef std::future<SetLiveMpuTaskSeiOutcome> SetLiveMpuTaskSeiOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::SetLiveMpuTaskSeiRequest&, const SetLiveMpuTaskSeiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveMpuTaskSeiAsyncHandler;
 			typedef Outcome<Error, Model::SetLiveStreamDelayConfigResult> SetLiveStreamDelayConfigOutcome;
 			typedef std::future<SetLiveStreamDelayConfigOutcome> SetLiveStreamDelayConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::SetLiveStreamDelayConfigRequest&, const SetLiveStreamDelayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveStreamDelayConfigAsyncHandler;
@@ -1882,6 +1892,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;
+			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;
 			DescribeLiveDetectNotifyConfigOutcome describeLiveDetectNotifyConfig(const Model::DescribeLiveDetectNotifyConfigRequest &request)const;
 			void describeLiveDetectNotifyConfigAsync(const Model::DescribeLiveDetectNotifyConfigRequest& request, const DescribeLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveDetectNotifyConfigOutcomeCallable describeLiveDetectNotifyConfigCallable(const Model::DescribeLiveDetectNotifyConfigRequest& request) const;
@@ -2347,6 +2360,9 @@ namespace AlibabaCloud
 			SetLiveLazyPullStreamInfoConfigOutcome setLiveLazyPullStreamInfoConfig(const Model::SetLiveLazyPullStreamInfoConfigRequest &request)const;
 			void setLiveLazyPullStreamInfoConfigAsync(const Model::SetLiveLazyPullStreamInfoConfigRequest& request, const SetLiveLazyPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetLiveLazyPullStreamInfoConfigOutcomeCallable setLiveLazyPullStreamInfoConfigCallable(const Model::SetLiveLazyPullStreamInfoConfigRequest& request) const;
+			SetLiveMpuTaskSeiOutcome setLiveMpuTaskSei(const Model::SetLiveMpuTaskSeiRequest &request)const;
+			void setLiveMpuTaskSeiAsync(const Model::SetLiveMpuTaskSeiRequest& request, const SetLiveMpuTaskSeiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetLiveMpuTaskSeiOutcomeCallable setLiveMpuTaskSeiCallable(const Model::SetLiveMpuTaskSeiRequest& request) const;
 			SetLiveStreamDelayConfigOutcome setLiveStreamDelayConfig(const Model::SetLiveStreamDelayConfigRequest &request)const;
 			void setLiveStreamDelayConfigAsync(const Model::SetLiveStreamDelayConfigRequest& request, const SetLiveStreamDelayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetLiveStreamDelayConfigOutcomeCallable setLiveStreamDelayConfigCallable(const Model::SetLiveStreamDelayConfigRequest& request) const;

live/include/alibabacloud/live/model/AddLiveStreamWatermarkRequest.h

@@ -48,6 +48,8 @@ public:
 	void setRefWidth(int refWidth);
 	int getTransparency() const;
 	void setTransparency(int transparency);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
 	std::string getName() const;
 	void setName(const std::string &name);
 	std::string getOffsetCorner() const;
@@ -65,6 +67,7 @@ private:
 	long ownerId_;
 	int refWidth_;
 	int transparency_;
+	std::string domain_;
 	std::string name_;
 	std::string offsetCorner_;
 	int refHeight_;

live/include/alibabacloud/live/model/CreateLiveStreamRecordIndexFilesRequest.h

@@ -40,6 +40,8 @@ public:
 	void setAppName(const std::string &appName);
 	std::string getSecurityToken() const;
 	void setSecurityToken(const std::string &securityToken);
+	bool getEndTimeIncluded() const;
+	void setEndTimeIncluded(bool endTimeIncluded);
 	std::string getStreamName() const;
 	void setStreamName(const std::string &streamName);
 	std::string getOssBucket() const;
@@ -57,6 +59,7 @@ private:
 	std::string ossObject_;
 	std::string appName_;
 	std::string securityToken_;
+	bool endTimeIncluded_;
 	std::string streamName_;
 	std::string ossBucket_;
 	std::string domainName_;

live/include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYEDSTREAMINGUSAGEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYEDSTREAMINGUSAGEREQUEST_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 DescribeLiveDelayedStreamingUsageRequest : public RpcServiceRequest {
+public:
+	DescribeLiveDelayedStreamingUsageRequest();
+	~DescribeLiveDelayedStreamingUsageRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	std::string getSplitBy() const;
+	void setSplitBy(const std::string &splitBy);
+	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 getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string startTime_;
+	std::string streamName_;
+	std::string splitBy_;
+	std::string domainName_;
+	std::string endTime_;
+	long ownerId_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYEDSTREAMINGUSAGEREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDelayedStreamingUsageResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYEDSTREAMINGUSAGERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYEDSTREAMINGUSAGERESULT_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 DescribeLiveDelayedStreamingUsageResult : public ServiceResult
+			{
+			public:
+				struct DelayDataItem
+				{
+					std::string streamName;
+					std::string domainName;
+					std::string region;
+					long duration;
+					std::string timeStamp;
+				};
+
+
+				DescribeLiveDelayedStreamingUsageResult();
+				explicit DescribeLiveDelayedStreamingUsageResult(const std::string &payload);
+				~DescribeLiveDelayedStreamingUsageResult();
+				std::string getEndTime()const;
+				std::string getStartTime()const;
+				std::vector<DelayDataItem> getDelayData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string startTime_;
+				std::vector<DelayDataItem> delayData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDELAYEDSTREAMINGUSAGERESULT_H_

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

@@ -40,6 +40,8 @@ public:
 	void setEndTime(const std::string &endTime);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	std::string getInterval() const;
+	void setInterval(const std::string &interval);
 
 private:
 	std::string startTime_;
@@ -47,6 +49,7 @@ private:
 	std::string domainName_;
 	std::string endTime_;
 	long ownerId_;
+	std::string interval_;
 };
 } // namespace Model
 } // namespace Live

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

@@ -45,11 +45,15 @@ namespace AlibabaCloud
 				DescribeLiveDomainRecordUsageDataResult();
 				explicit DescribeLiveDomainRecordUsageDataResult(const std::string &payload);
 				~DescribeLiveDomainRecordUsageDataResult();
+				std::string getEndTime()const;
+				std::string getStartTime()const;
 				std::vector<DataModule> getRecordUsageData()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string endTime_;
+				std::string startTime_;
 				std::vector<DataModule> recordUsageData_;
 
 			};

live/include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesRequest.h

@@ -36,11 +36,14 @@ public:
 	void setPageSize(int pageSize);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
 
 private:
 	int pageNumber_;
 	int pageSize_;
 	long ownerId_;
+	std::string domain_;
 };
 } // namespace Model
 } // namespace Live

live/include/alibabacloud/live/model/DescribeLiveStreamWatermarkRulesResult.h

@@ -48,11 +48,13 @@ namespace AlibabaCloud
 				explicit DescribeLiveStreamWatermarkRulesResult(const std::string &payload);
 				~DescribeLiveStreamWatermarkRulesResult();
 				std::vector<RuleInfo> getRuleInfoList()const;
+				int getTotal()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::vector<RuleInfo> ruleInfoList_;
+				int total_;
 
 			};
 		}

live/include/alibabacloud/live/model/DescribeLiveStreamWatermarksRequest.h

@@ -34,13 +34,19 @@ public:
 	void setPageNumber(int pageNumber);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
+	std::string getKeyWord() const;
+	void setKeyWord(const std::string &keyWord);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
 
 private:
 	int pageNumber_;
 	int pageSize_;
+	std::string keyWord_;
 	long ownerId_;
+	std::string domain_;
 };
 } // namespace Model
 } // namespace Live

live/include/alibabacloud/live/model/DescribeLiveStreamWatermarksResult.h

@@ -34,18 +34,19 @@ namespace AlibabaCloud
 			public:
 				struct Watermark
 				{
+					int ruleCount;
 					int refHeight;
-					int type;
 					int transparency;
 					std::string description;
-					std::string pictureUrl;
 					float yOffset;
-					int height;
 					std::string offsetCorner;
 					float xOffset;
 					int refWidth;
-					std::string templateId;
 					std::string name;
+					int type;
+					std::string pictureUrl;
+					int height;
+					std::string templateId;
 				};
 
 
@@ -53,11 +54,13 @@ namespace AlibabaCloud
 				explicit DescribeLiveStreamWatermarksResult(const std::string &payload);
 				~DescribeLiveStreamWatermarksResult();
 				std::vector<Watermark> getWatermarkList()const;
+				int getTotal()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::vector<Watermark> watermarkList_;
+				int total_;
 
 			};
 		}

live/include/alibabacloud/live/model/DescribeLiveUserBillPredictionRequest.h

@@ -32,10 +32,6 @@ public:
 	~DescribeLiveUserBillPredictionRequest();
 	std::string getStartTime() const;
 	void setStartTime(const std::string &startTime);
-	std::string getDimension() const;
-	void setDimension(const std::string &dimension);
-	std::string getArea() const;
-	void setArea(const std::string &area);
 	std::string getEndTime() const;
 	void setEndTime(const std::string &endTime);
 	long getOwnerId() const;
@@ -43,8 +39,6 @@ public:
 
 private:
 	std::string startTime_;
-	std::string dimension_;
-	std::string area_;
 	std::string endTime_;
 	long ownerId_;
 };

live/include/alibabacloud/live/model/SetLiveMpuTaskSeiRequest.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_SETLIVEMPUTASKSEIREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_SETLIVEMPUTASKSEIREQUEST_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 SetLiveMpuTaskSeiRequest : public RpcServiceRequest {
+public:
+	SetLiveMpuTaskSeiRequest();
+	~SetLiveMpuTaskSeiRequest();
+	std::string getCustomSei() const;
+	void setCustomSei(const std::string &customSei);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getTaskId() const;
+	void setTaskId(const std::string &taskId);
+
+private:
+	std::string customSei_;
+	std::string appId_;
+	std::string taskId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_SETLIVEMPUTASKSEIREQUEST_H_

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

live/src/LiveClient.cc

@@ -4083,6 +4083,42 @@ LiveClient::DescribeLiveCertificateListOutcomeCallable LiveClient::describeLiveC
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveDelayedStreamingUsageOutcome LiveClient::describeLiveDelayedStreamingUsage(const DescribeLiveDelayedStreamingUsageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveDelayedStreamingUsageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveDelayedStreamingUsageOutcome(DescribeLiveDelayedStreamingUsageResult(outcome.result()));
+	else
+		return DescribeLiveDelayedStreamingUsageOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveDelayedStreamingUsageAsync(const DescribeLiveDelayedStreamingUsageRequest& request, const DescribeLiveDelayedStreamingUsageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveDelayedStreamingUsage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveDelayedStreamingUsageOutcomeCallable LiveClient::describeLiveDelayedStreamingUsageCallable(const DescribeLiveDelayedStreamingUsageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveDelayedStreamingUsageOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveDelayedStreamingUsage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveDetectNotifyConfigOutcome LiveClient::describeLiveDetectNotifyConfig(const DescribeLiveDetectNotifyConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -9663,6 +9699,42 @@ LiveClient::SetLiveLazyPullStreamInfoConfigOutcomeCallable LiveClient::setLiveLa
 	return task->get_future();
 }
 
+LiveClient::SetLiveMpuTaskSeiOutcome LiveClient::setLiveMpuTaskSei(const SetLiveMpuTaskSeiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetLiveMpuTaskSeiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetLiveMpuTaskSeiOutcome(SetLiveMpuTaskSeiResult(outcome.result()));
+	else
+		return SetLiveMpuTaskSeiOutcome(outcome.error());
+}
+
+void LiveClient::setLiveMpuTaskSeiAsync(const SetLiveMpuTaskSeiRequest& request, const SetLiveMpuTaskSeiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setLiveMpuTaskSei(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::SetLiveMpuTaskSeiOutcomeCallable LiveClient::setLiveMpuTaskSeiCallable(const SetLiveMpuTaskSeiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetLiveMpuTaskSeiOutcome()>>(
+			[this, request]()
+			{
+			return this->setLiveMpuTaskSei(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::SetLiveStreamDelayConfigOutcome LiveClient::setLiveStreamDelayConfig(const SetLiveStreamDelayConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/AddLiveStreamWatermarkRequest.cc

@@ -106,6 +106,15 @@ void AddLiveStreamWatermarkRequest::setTransparency(int transparency) {
   setParameter(std::string("Transparency"), std::to_string(transparency));
 }
 
+std::string AddLiveStreamWatermarkRequest::getDomain() const {
+  return domain_;
+}
+
+void AddLiveStreamWatermarkRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+
 std::string AddLiveStreamWatermarkRequest::getName() const {
   return name_;
 }

live/src/model/CreateLiveStreamRecordIndexFilesRequest.cc

@@ -70,6 +70,15 @@ void CreateLiveStreamRecordIndexFilesRequest::setSecurityToken(const std::string
   setParameter(std::string("SecurityToken"), securityToken);
 }
 
+bool CreateLiveStreamRecordIndexFilesRequest::getEndTimeIncluded() const {
+  return endTimeIncluded_;
+}
+
+void CreateLiveStreamRecordIndexFilesRequest::setEndTimeIncluded(bool endTimeIncluded) {
+  endTimeIncluded_ = endTimeIncluded;
+  setParameter(std::string("EndTimeIncluded"), endTimeIncluded ? "true" : "false");
+}
+
 std::string CreateLiveStreamRecordIndexFilesRequest::getStreamName() const {
   return streamName_;
 }

live/src/model/DescribeLiveDelayedStreamingUsageRequest.cc

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

live/src/model/DescribeLiveDelayedStreamingUsageResult.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/DescribeLiveDelayedStreamingUsageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDelayedStreamingUsageResult::DescribeLiveDelayedStreamingUsageResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDelayedStreamingUsageResult::DescribeLiveDelayedStreamingUsageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDelayedStreamingUsageResult::~DescribeLiveDelayedStreamingUsageResult()
+{}
+
+void DescribeLiveDelayedStreamingUsageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDelayDataNode = value["DelayData"]["DelayDataItem"];
+	for (auto valueDelayDataDelayDataItem : allDelayDataNode)
+	{
+		DelayDataItem delayDataObject;
+		if(!valueDelayDataDelayDataItem["Duration"].isNull())
+			delayDataObject.duration = std::stol(valueDelayDataDelayDataItem["Duration"].asString());
+		if(!valueDelayDataDelayDataItem["TimeStamp"].isNull())
+			delayDataObject.timeStamp = valueDelayDataDelayDataItem["TimeStamp"].asString();
+		if(!valueDelayDataDelayDataItem["StreamName"].isNull())
+			delayDataObject.streamName = valueDelayDataDelayDataItem["StreamName"].asString();
+		if(!valueDelayDataDelayDataItem["DomainName"].isNull())
+			delayDataObject.domainName = valueDelayDataDelayDataItem["DomainName"].asString();
+		if(!valueDelayDataDelayDataItem["Region"].isNull())
+			delayDataObject.region = valueDelayDataDelayDataItem["Region"].asString();
+		delayData_.push_back(delayDataObject);
+	}
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+
+}
+
+std::string DescribeLiveDelayedStreamingUsageResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeLiveDelayedStreamingUsageResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeLiveDelayedStreamingUsageResult::DelayDataItem> DescribeLiveDelayedStreamingUsageResult::getDelayData()const
+{
+	return delayData_;
+}
+

live/src/model/DescribeLiveDomainRecordUsageDataRequest.cc

@@ -70,3 +70,12 @@ void DescribeLiveDomainRecordUsageDataRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string DescribeLiveDomainRecordUsageDataRequest::getInterval() const {
+  return interval_;
+}
+
+void DescribeLiveDomainRecordUsageDataRequest::setInterval(const std::string &interval) {
+  interval_ = interval;
+  setParameter(std::string("Interval"), interval);
+}
+

live/src/model/DescribeLiveDomainRecordUsageDataResult.cc

@@ -55,9 +55,23 @@ void DescribeLiveDomainRecordUsageDataResult::parse(const std::string &payload)
 			recordUsageDataObject.count = std::stol(valueRecordUsageDataDataModule["Count"].asString());
 		recordUsageData_.push_back(recordUsageDataObject);
 	}
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 
+std::string DescribeLiveDomainRecordUsageDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeLiveDomainRecordUsageDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
 std::vector<DescribeLiveDomainRecordUsageDataResult::DataModule> DescribeLiveDomainRecordUsageDataResult::getRecordUsageData()const
 {
 	return recordUsageData_;

live/src/model/DescribeLiveStreamWatermarkRulesRequest.cc

@@ -52,3 +52,12 @@ void DescribeLiveStreamWatermarkRulesRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string DescribeLiveStreamWatermarkRulesRequest::getDomain() const {
+  return domain_;
+}
+
+void DescribeLiveStreamWatermarkRulesRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

live/src/model/DescribeLiveStreamWatermarkRulesResult.cc

@@ -59,6 +59,8 @@ void DescribeLiveStreamWatermarkRulesResult::parse(const std::string &payload)
 			ruleInfoListObject.ruleId = valueRuleInfoListRuleInfo["RuleId"].asString();
 		ruleInfoList_.push_back(ruleInfoListObject);
 	}
+	if(!value["Total"].isNull())
+		total_ = std::stoi(value["Total"].asString());
 
 }
 
@@ -67,3 +69,8 @@ std::vector<DescribeLiveStreamWatermarkRulesResult::RuleInfo> DescribeLiveStream
 	return ruleInfoList_;
 }
 
+int DescribeLiveStreamWatermarkRulesResult::getTotal()const
+{
+	return total_;
+}
+

live/src/model/DescribeLiveStreamWatermarksRequest.cc

@@ -43,6 +43,15 @@ void DescribeLiveStreamWatermarksRequest::setPageSize(int pageSize) {
   setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
+std::string DescribeLiveStreamWatermarksRequest::getKeyWord() const {
+  return keyWord_;
+}
+
+void DescribeLiveStreamWatermarksRequest::setKeyWord(const std::string &keyWord) {
+  keyWord_ = keyWord;
+  setParameter(std::string("KeyWord"), keyWord);
+}
+
 long DescribeLiveStreamWatermarksRequest::getOwnerId() const {
   return ownerId_;
 }
@@ -52,3 +61,12 @@ void DescribeLiveStreamWatermarksRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string DescribeLiveStreamWatermarksRequest::getDomain() const {
+  return domain_;
+}
+
+void DescribeLiveStreamWatermarksRequest::setDomain(const std::string &domain) {
+  domain_ = domain;
+  setParameter(std::string("Domain"), domain);
+}
+

live/src/model/DescribeLiveStreamWatermarksResult.cc

@@ -63,12 +63,16 @@ void DescribeLiveStreamWatermarksResult::parse(const std::string &payload)
 			watermarkListObject.description = valueWatermarkListWatermark["Description"].asString();
 		if(!valueWatermarkListWatermark["OffsetCorner"].isNull())
 			watermarkListObject.offsetCorner = valueWatermarkListWatermark["OffsetCorner"].asString();
+		if(!valueWatermarkListWatermark["RuleCount"].isNull())
+			watermarkListObject.ruleCount = std::stoi(valueWatermarkListWatermark["RuleCount"].asString());
 		if(!valueWatermarkListWatermark["Name"].isNull())
 			watermarkListObject.name = valueWatermarkListWatermark["Name"].asString();
 		if(!valueWatermarkListWatermark["TemplateId"].isNull())
 			watermarkListObject.templateId = valueWatermarkListWatermark["TemplateId"].asString();
 		watermarkList_.push_back(watermarkListObject);
 	}
+	if(!value["Total"].isNull())
+		total_ = std::stoi(value["Total"].asString());
 
 }
 
@@ -77,3 +81,8 @@ std::vector<DescribeLiveStreamWatermarksResult::Watermark> DescribeLiveStreamWat
 	return watermarkList_;
 }
 
+int DescribeLiveStreamWatermarksResult::getTotal()const
+{
+	return total_;
+}
+

live/src/model/DescribeLiveUserBillPredictionRequest.cc

@@ -34,24 +34,6 @@ void DescribeLiveUserBillPredictionRequest::setStartTime(const std::string &star
   setParameter(std::string("StartTime"), startTime);
 }
 
-std::string DescribeLiveUserBillPredictionRequest::getDimension() const {
-  return dimension_;
-}
-
-void DescribeLiveUserBillPredictionRequest::setDimension(const std::string &dimension) {
-  dimension_ = dimension;
-  setParameter(std::string("Dimension"), dimension);
-}
-
-std::string DescribeLiveUserBillPredictionRequest::getArea() const {
-  return area_;
-}
-
-void DescribeLiveUserBillPredictionRequest::setArea(const std::string &area) {
-  area_ = area;
-  setParameter(std::string("Area"), area);
-}
-
 std::string DescribeLiveUserBillPredictionRequest::getEndTime() const {
   return endTime_;
 }

live/src/model/SetLiveMpuTaskSeiRequest.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/SetLiveMpuTaskSeiRequest.h>
+
+using AlibabaCloud::Live::Model::SetLiveMpuTaskSeiRequest;
+
+SetLiveMpuTaskSeiRequest::SetLiveMpuTaskSeiRequest()
+    : RpcServiceRequest("live", "2016-11-01", "SetLiveMpuTaskSei") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SetLiveMpuTaskSeiRequest::~SetLiveMpuTaskSeiRequest() {}
+
+std::string SetLiveMpuTaskSeiRequest::getCustomSei() const {
+  return customSei_;
+}
+
+void SetLiveMpuTaskSeiRequest::setCustomSei(const std::string &customSei) {
+  customSei_ = customSei;
+  setParameter(std::string("CustomSei"), customSei);
+}
+
+std::string SetLiveMpuTaskSeiRequest::getAppId() const {
+  return appId_;
+}
+
+void SetLiveMpuTaskSeiRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+std::string SetLiveMpuTaskSeiRequest::getTaskId() const {
+  return taskId_;
+}
+
+void SetLiveMpuTaskSeiRequest::setTaskId(const std::string &taskId) {
+  taskId_ = taskId;
+  setParameter(std::string("TaskId"), taskId);
+}
+

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