Update to support new apis.

VERSION

@@ -1 +1 @@
-1.36.1913
+1.36.1914

live/CMakeLists.txt

@@ -123,6 +123,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/CreateLiveMessageAppResult.h
 	include/alibabacloud/live/model/CreateLiveMessageGroupRequest.h
 	include/alibabacloud/live/model/CreateLiveMessageGroupResult.h
+	include/alibabacloud/live/model/CreateLivePrivateLineRequest.h
+	include/alibabacloud/live/model/CreateLivePrivateLineResult.h
 	include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryRequest.h
 	include/alibabacloud/live/model/CreateLiveRealTimeLogDeliveryResult.h
 	include/alibabacloud/live/model/CreateLiveStreamMonitorRequest.h
@@ -195,6 +197,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DeleteLiveMessageUserMessageResult.h
 	include/alibabacloud/live/model/DeleteLivePackageConfigRequest.h
 	include/alibabacloud/live/model/DeleteLivePackageConfigResult.h
+	include/alibabacloud/live/model/DeleteLivePrivateLineRequest.h
+	include/alibabacloud/live/model/DeleteLivePrivateLineResult.h
 	include/alibabacloud/live/model/DeleteLivePullStreamInfoConfigRequest.h
 	include/alibabacloud/live/model/DeleteLivePullStreamInfoConfigResult.h
 	include/alibabacloud/live/model/DeleteLiveRealTimeLogLogstoreRequest.h
@@ -391,6 +395,10 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveMessageGroupBandResult.h
 	include/alibabacloud/live/model/DescribeLivePackageConfigRequest.h
 	include/alibabacloud/live/model/DescribeLivePackageConfigResult.h
+	include/alibabacloud/live/model/DescribeLivePrivateLineAreasRequest.h
+	include/alibabacloud/live/model/DescribeLivePrivateLineAreasResult.h
+	include/alibabacloud/live/model/DescribeLivePrivateLineAvailGARequest.h
+	include/alibabacloud/live/model/DescribeLivePrivateLineAvailGAResult.h
 	include/alibabacloud/live/model/DescribeLiveProducerUsageDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveProducerUsageDataResult.h
 	include/alibabacloud/live/model/DescribeLivePullStreamConfigRequest.h
@@ -431,6 +439,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveStreamDetailFrameRateAndBitRateDataResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamHistoryUserNumRequest.h
 	include/alibabacloud/live/model/DescribeLiveStreamHistoryUserNumResult.h
+	include/alibabacloud/live/model/DescribeLiveStreamMergeRequest.h
+	include/alibabacloud/live/model/DescribeLiveStreamMergeResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamMetricDetailDataRequest.h
 	include/alibabacloud/live/model/DescribeLiveStreamMetricDetailDataResult.h
 	include/alibabacloud/live/model/DescribeLiveStreamMonitorListRequest.h
@@ -487,6 +497,8 @@ set(live_public_header_model
 	include/alibabacloud/live/model/DescribeLiveUserDomainsResult.h
 	include/alibabacloud/live/model/DescribeLiveUserTagsRequest.h
 	include/alibabacloud/live/model/DescribeLiveUserTagsResult.h
+	include/alibabacloud/live/model/DescribeMeterLiveBypassDurationRequest.h
+	include/alibabacloud/live/model/DescribeMeterLiveBypassDurationResult.h
 	include/alibabacloud/live/model/DescribeMeterLiveInteractionDauRequest.h
 	include/alibabacloud/live/model/DescribeMeterLiveInteractionDauResult.h
 	include/alibabacloud/live/model/DescribeMeterLiveRtcDurationRequest.h
@@ -914,6 +926,8 @@ set(live_src
 	src/model/CreateLiveMessageAppResult.cc
 	src/model/CreateLiveMessageGroupRequest.cc
 	src/model/CreateLiveMessageGroupResult.cc
+	src/model/CreateLivePrivateLineRequest.cc
+	src/model/CreateLivePrivateLineResult.cc
 	src/model/CreateLiveRealTimeLogDeliveryRequest.cc
 	src/model/CreateLiveRealTimeLogDeliveryResult.cc
 	src/model/CreateLiveStreamMonitorRequest.cc
@@ -986,6 +1000,8 @@ set(live_src
 	src/model/DeleteLiveMessageUserMessageResult.cc
 	src/model/DeleteLivePackageConfigRequest.cc
 	src/model/DeleteLivePackageConfigResult.cc
+	src/model/DeleteLivePrivateLineRequest.cc
+	src/model/DeleteLivePrivateLineResult.cc
 	src/model/DeleteLivePullStreamInfoConfigRequest.cc
 	src/model/DeleteLivePullStreamInfoConfigResult.cc
 	src/model/DeleteLiveRealTimeLogLogstoreRequest.cc
@@ -1182,6 +1198,10 @@ set(live_src
 	src/model/DescribeLiveMessageGroupBandResult.cc
 	src/model/DescribeLivePackageConfigRequest.cc
 	src/model/DescribeLivePackageConfigResult.cc
+	src/model/DescribeLivePrivateLineAreasRequest.cc
+	src/model/DescribeLivePrivateLineAreasResult.cc
+	src/model/DescribeLivePrivateLineAvailGARequest.cc
+	src/model/DescribeLivePrivateLineAvailGAResult.cc
 	src/model/DescribeLiveProducerUsageDataRequest.cc
 	src/model/DescribeLiveProducerUsageDataResult.cc
 	src/model/DescribeLivePullStreamConfigRequest.cc
@@ -1222,6 +1242,8 @@ set(live_src
 	src/model/DescribeLiveStreamDetailFrameRateAndBitRateDataResult.cc
 	src/model/DescribeLiveStreamHistoryUserNumRequest.cc
 	src/model/DescribeLiveStreamHistoryUserNumResult.cc
+	src/model/DescribeLiveStreamMergeRequest.cc
+	src/model/DescribeLiveStreamMergeResult.cc
 	src/model/DescribeLiveStreamMetricDetailDataRequest.cc
 	src/model/DescribeLiveStreamMetricDetailDataResult.cc
 	src/model/DescribeLiveStreamMonitorListRequest.cc
@@ -1278,6 +1300,8 @@ set(live_src
 	src/model/DescribeLiveUserDomainsResult.cc
 	src/model/DescribeLiveUserTagsRequest.cc
 	src/model/DescribeLiveUserTagsResult.cc
+	src/model/DescribeMeterLiveBypassDurationRequest.cc
+	src/model/DescribeMeterLiveBypassDurationResult.cc
 	src/model/DescribeMeterLiveInteractionDauRequest.cc
 	src/model/DescribeMeterLiveInteractionDauResult.cc
 	src/model/DescribeMeterLiveRtcDurationRequest.cc

live/include/alibabacloud/live/LiveClient.h

@@ -124,6 +124,8 @@
 #include "model/CreateLiveMessageAppResult.h"
 #include "model/CreateLiveMessageGroupRequest.h"
 #include "model/CreateLiveMessageGroupResult.h"
+#include "model/CreateLivePrivateLineRequest.h"
+#include "model/CreateLivePrivateLineResult.h"
 #include "model/CreateLiveRealTimeLogDeliveryRequest.h"
 #include "model/CreateLiveRealTimeLogDeliveryResult.h"
 #include "model/CreateLiveStreamMonitorRequest.h"
@@ -196,6 +198,8 @@
 #include "model/DeleteLiveMessageUserMessageResult.h"
 #include "model/DeleteLivePackageConfigRequest.h"
 #include "model/DeleteLivePackageConfigResult.h"
+#include "model/DeleteLivePrivateLineRequest.h"
+#include "model/DeleteLivePrivateLineResult.h"
 #include "model/DeleteLivePullStreamInfoConfigRequest.h"
 #include "model/DeleteLivePullStreamInfoConfigResult.h"
 #include "model/DeleteLiveRealTimeLogLogstoreRequest.h"
@@ -392,6 +396,10 @@
 #include "model/DescribeLiveMessageGroupBandResult.h"
 #include "model/DescribeLivePackageConfigRequest.h"
 #include "model/DescribeLivePackageConfigResult.h"
+#include "model/DescribeLivePrivateLineAreasRequest.h"
+#include "model/DescribeLivePrivateLineAreasResult.h"
+#include "model/DescribeLivePrivateLineAvailGARequest.h"
+#include "model/DescribeLivePrivateLineAvailGAResult.h"
 #include "model/DescribeLiveProducerUsageDataRequest.h"
 #include "model/DescribeLiveProducerUsageDataResult.h"
 #include "model/DescribeLivePullStreamConfigRequest.h"
@@ -432,6 +440,8 @@
 #include "model/DescribeLiveStreamDetailFrameRateAndBitRateDataResult.h"
 #include "model/DescribeLiveStreamHistoryUserNumRequest.h"
 #include "model/DescribeLiveStreamHistoryUserNumResult.h"
+#include "model/DescribeLiveStreamMergeRequest.h"
+#include "model/DescribeLiveStreamMergeResult.h"
 #include "model/DescribeLiveStreamMetricDetailDataRequest.h"
 #include "model/DescribeLiveStreamMetricDetailDataResult.h"
 #include "model/DescribeLiveStreamMonitorListRequest.h"
@@ -488,6 +498,8 @@
 #include "model/DescribeLiveUserDomainsResult.h"
 #include "model/DescribeLiveUserTagsRequest.h"
 #include "model/DescribeLiveUserTagsResult.h"
+#include "model/DescribeMeterLiveBypassDurationRequest.h"
+#include "model/DescribeMeterLiveBypassDurationResult.h"
 #include "model/DescribeMeterLiveInteractionDauRequest.h"
 #include "model/DescribeMeterLiveInteractionDauResult.h"
 #include "model/DescribeMeterLiveRtcDurationRequest.h"
@@ -972,6 +984,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateLiveMessageGroupResult> CreateLiveMessageGroupOutcome;
 			typedef std::future<CreateLiveMessageGroupOutcome> CreateLiveMessageGroupOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::CreateLiveMessageGroupRequest&, const CreateLiveMessageGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveMessageGroupAsyncHandler;
+			typedef Outcome<Error, Model::CreateLivePrivateLineResult> CreateLivePrivateLineOutcome;
+			typedef std::future<CreateLivePrivateLineOutcome> CreateLivePrivateLineOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::CreateLivePrivateLineRequest&, const CreateLivePrivateLineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLivePrivateLineAsyncHandler;
 			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;
@@ -1080,6 +1095,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteLivePackageConfigResult> DeleteLivePackageConfigOutcome;
 			typedef std::future<DeleteLivePackageConfigOutcome> DeleteLivePackageConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteLivePackageConfigRequest&, const DeleteLivePackageConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLivePackageConfigAsyncHandler;
+			typedef Outcome<Error, Model::DeleteLivePrivateLineResult> DeleteLivePrivateLineOutcome;
+			typedef std::future<DeleteLivePrivateLineOutcome> DeleteLivePrivateLineOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DeleteLivePrivateLineRequest&, const DeleteLivePrivateLineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLivePrivateLineAsyncHandler;
 			typedef Outcome<Error, Model::DeleteLivePullStreamInfoConfigResult> DeleteLivePullStreamInfoConfigOutcome;
 			typedef std::future<DeleteLivePullStreamInfoConfigOutcome> DeleteLivePullStreamInfoConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DeleteLivePullStreamInfoConfigRequest&, const DeleteLivePullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLivePullStreamInfoConfigAsyncHandler;
@@ -1374,6 +1392,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLivePackageConfigResult> DescribeLivePackageConfigOutcome;
 			typedef std::future<DescribeLivePackageConfigOutcome> DescribeLivePackageConfigOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLivePackageConfigRequest&, const DescribeLivePackageConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePackageConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLivePrivateLineAreasResult> DescribeLivePrivateLineAreasOutcome;
+			typedef std::future<DescribeLivePrivateLineAreasOutcome> DescribeLivePrivateLineAreasOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLivePrivateLineAreasRequest&, const DescribeLivePrivateLineAreasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePrivateLineAreasAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLivePrivateLineAvailGAResult> DescribeLivePrivateLineAvailGAOutcome;
+			typedef std::future<DescribeLivePrivateLineAvailGAOutcome> DescribeLivePrivateLineAvailGAOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLivePrivateLineAvailGARequest&, const DescribeLivePrivateLineAvailGAOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePrivateLineAvailGAAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveProducerUsageDataResult> DescribeLiveProducerUsageDataOutcome;
 			typedef std::future<DescribeLiveProducerUsageDataOutcome> DescribeLiveProducerUsageDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveProducerUsageDataRequest&, const DescribeLiveProducerUsageDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveProducerUsageDataAsyncHandler;
@@ -1434,6 +1458,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveStreamHistoryUserNumResult> DescribeLiveStreamHistoryUserNumOutcome;
 			typedef std::future<DescribeLiveStreamHistoryUserNumOutcome> DescribeLiveStreamHistoryUserNumOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamHistoryUserNumRequest&, const DescribeLiveStreamHistoryUserNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamHistoryUserNumAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLiveStreamMergeResult> DescribeLiveStreamMergeOutcome;
+			typedef std::future<DescribeLiveStreamMergeOutcome> DescribeLiveStreamMergeOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamMergeRequest&, const DescribeLiveStreamMergeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamMergeAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLiveStreamMetricDetailDataResult> DescribeLiveStreamMetricDetailDataOutcome;
 			typedef std::future<DescribeLiveStreamMetricDetailDataOutcome> DescribeLiveStreamMetricDetailDataOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamMetricDetailDataRequest&, const DescribeLiveStreamMetricDetailDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamMetricDetailDataAsyncHandler;
@@ -1518,6 +1545,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLiveUserTagsResult> DescribeLiveUserTagsOutcome;
 			typedef std::future<DescribeLiveUserTagsOutcome> DescribeLiveUserTagsOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeLiveUserTagsRequest&, const DescribeLiveUserTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveUserTagsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeMeterLiveBypassDurationResult> DescribeMeterLiveBypassDurationOutcome;
+			typedef std::future<DescribeMeterLiveBypassDurationOutcome> DescribeMeterLiveBypassDurationOutcomeCallable;
+			typedef std::function<void(const LiveClient*, const Model::DescribeMeterLiveBypassDurationRequest&, const DescribeMeterLiveBypassDurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMeterLiveBypassDurationAsyncHandler;
 			typedef Outcome<Error, Model::DescribeMeterLiveInteractionDauResult> DescribeMeterLiveInteractionDauOutcome;
 			typedef std::future<DescribeMeterLiveInteractionDauOutcome> DescribeMeterLiveInteractionDauOutcomeCallable;
 			typedef std::function<void(const LiveClient*, const Model::DescribeMeterLiveInteractionDauRequest&, const DescribeMeterLiveInteractionDauOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMeterLiveInteractionDauAsyncHandler;
@@ -2159,6 +2189,9 @@ namespace AlibabaCloud
 			CreateLiveMessageGroupOutcome createLiveMessageGroup(const Model::CreateLiveMessageGroupRequest &request)const;
 			void createLiveMessageGroupAsync(const Model::CreateLiveMessageGroupRequest& request, const CreateLiveMessageGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateLiveMessageGroupOutcomeCallable createLiveMessageGroupCallable(const Model::CreateLiveMessageGroupRequest& request) const;
+			CreateLivePrivateLineOutcome createLivePrivateLine(const Model::CreateLivePrivateLineRequest &request)const;
+			void createLivePrivateLineAsync(const Model::CreateLivePrivateLineRequest& request, const CreateLivePrivateLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateLivePrivateLineOutcomeCallable createLivePrivateLineCallable(const Model::CreateLivePrivateLineRequest& 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;
@@ -2267,6 +2300,9 @@ namespace AlibabaCloud
 			DeleteLivePackageConfigOutcome deleteLivePackageConfig(const Model::DeleteLivePackageConfigRequest &request)const;
 			void deleteLivePackageConfigAsync(const Model::DeleteLivePackageConfigRequest& request, const DeleteLivePackageConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLivePackageConfigOutcomeCallable deleteLivePackageConfigCallable(const Model::DeleteLivePackageConfigRequest& request) const;
+			DeleteLivePrivateLineOutcome deleteLivePrivateLine(const Model::DeleteLivePrivateLineRequest &request)const;
+			void deleteLivePrivateLineAsync(const Model::DeleteLivePrivateLineRequest& request, const DeleteLivePrivateLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteLivePrivateLineOutcomeCallable deleteLivePrivateLineCallable(const Model::DeleteLivePrivateLineRequest& request) const;
 			DeleteLivePullStreamInfoConfigOutcome deleteLivePullStreamInfoConfig(const Model::DeleteLivePullStreamInfoConfigRequest &request)const;
 			void deleteLivePullStreamInfoConfigAsync(const Model::DeleteLivePullStreamInfoConfigRequest& request, const DeleteLivePullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteLivePullStreamInfoConfigOutcomeCallable deleteLivePullStreamInfoConfigCallable(const Model::DeleteLivePullStreamInfoConfigRequest& request) const;
@@ -2561,6 +2597,12 @@ namespace AlibabaCloud
 			DescribeLivePackageConfigOutcome describeLivePackageConfig(const Model::DescribeLivePackageConfigRequest &request)const;
 			void describeLivePackageConfigAsync(const Model::DescribeLivePackageConfigRequest& request, const DescribeLivePackageConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLivePackageConfigOutcomeCallable describeLivePackageConfigCallable(const Model::DescribeLivePackageConfigRequest& request) const;
+			DescribeLivePrivateLineAreasOutcome describeLivePrivateLineAreas(const Model::DescribeLivePrivateLineAreasRequest &request)const;
+			void describeLivePrivateLineAreasAsync(const Model::DescribeLivePrivateLineAreasRequest& request, const DescribeLivePrivateLineAreasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLivePrivateLineAreasOutcomeCallable describeLivePrivateLineAreasCallable(const Model::DescribeLivePrivateLineAreasRequest& request) const;
+			DescribeLivePrivateLineAvailGAOutcome describeLivePrivateLineAvailGA(const Model::DescribeLivePrivateLineAvailGARequest &request)const;
+			void describeLivePrivateLineAvailGAAsync(const Model::DescribeLivePrivateLineAvailGARequest& request, const DescribeLivePrivateLineAvailGAAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLivePrivateLineAvailGAOutcomeCallable describeLivePrivateLineAvailGACallable(const Model::DescribeLivePrivateLineAvailGARequest& request) const;
 			DescribeLiveProducerUsageDataOutcome describeLiveProducerUsageData(const Model::DescribeLiveProducerUsageDataRequest &request)const;
 			void describeLiveProducerUsageDataAsync(const Model::DescribeLiveProducerUsageDataRequest& request, const DescribeLiveProducerUsageDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveProducerUsageDataOutcomeCallable describeLiveProducerUsageDataCallable(const Model::DescribeLiveProducerUsageDataRequest& request) const;
@@ -2621,6 +2663,9 @@ namespace AlibabaCloud
 			DescribeLiveStreamHistoryUserNumOutcome describeLiveStreamHistoryUserNum(const Model::DescribeLiveStreamHistoryUserNumRequest &request)const;
 			void describeLiveStreamHistoryUserNumAsync(const Model::DescribeLiveStreamHistoryUserNumRequest& request, const DescribeLiveStreamHistoryUserNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveStreamHistoryUserNumOutcomeCallable describeLiveStreamHistoryUserNumCallable(const Model::DescribeLiveStreamHistoryUserNumRequest& request) const;
+			DescribeLiveStreamMergeOutcome describeLiveStreamMerge(const Model::DescribeLiveStreamMergeRequest &request)const;
+			void describeLiveStreamMergeAsync(const Model::DescribeLiveStreamMergeRequest& request, const DescribeLiveStreamMergeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLiveStreamMergeOutcomeCallable describeLiveStreamMergeCallable(const Model::DescribeLiveStreamMergeRequest& request) const;
 			DescribeLiveStreamMetricDetailDataOutcome describeLiveStreamMetricDetailData(const Model::DescribeLiveStreamMetricDetailDataRequest &request)const;
 			void describeLiveStreamMetricDetailDataAsync(const Model::DescribeLiveStreamMetricDetailDataRequest& request, const DescribeLiveStreamMetricDetailDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveStreamMetricDetailDataOutcomeCallable describeLiveStreamMetricDetailDataCallable(const Model::DescribeLiveStreamMetricDetailDataRequest& request) const;
@@ -2705,6 +2750,9 @@ namespace AlibabaCloud
 			DescribeLiveUserTagsOutcome describeLiveUserTags(const Model::DescribeLiveUserTagsRequest &request)const;
 			void describeLiveUserTagsAsync(const Model::DescribeLiveUserTagsRequest& request, const DescribeLiveUserTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLiveUserTagsOutcomeCallable describeLiveUserTagsCallable(const Model::DescribeLiveUserTagsRequest& request) const;
+			DescribeMeterLiveBypassDurationOutcome describeMeterLiveBypassDuration(const Model::DescribeMeterLiveBypassDurationRequest &request)const;
+			void describeMeterLiveBypassDurationAsync(const Model::DescribeMeterLiveBypassDurationRequest& request, const DescribeMeterLiveBypassDurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeMeterLiveBypassDurationOutcomeCallable describeMeterLiveBypassDurationCallable(const Model::DescribeMeterLiveBypassDurationRequest& request) const;
 			DescribeMeterLiveInteractionDauOutcome describeMeterLiveInteractionDau(const Model::DescribeMeterLiveInteractionDauRequest &request)const;
 			void describeMeterLiveInteractionDauAsync(const Model::DescribeMeterLiveInteractionDauRequest& request, const DescribeMeterLiveInteractionDauAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeMeterLiveInteractionDauOutcomeCallable describeMeterLiveInteractionDauCallable(const Model::DescribeMeterLiveInteractionDauRequest& request) const;

live/include/alibabacloud/live/model/CreateLivePrivateLineRequest.h

@@ -0,0 +1,69 @@
+/*
+ * 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_CREATELIVEPRIVATELINEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_CREATELIVEPRIVATELINEREQUEST_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 CreateLivePrivateLineRequest : public RpcServiceRequest {
+public:
+	CreateLivePrivateLineRequest();
+	~CreateLivePrivateLineRequest();
+	std::string getMaxBandwidth() const;
+	void setMaxBandwidth(const std::string &maxBandwidth);
+	std::string getReuse() const;
+	void setReuse(const std::string &reuse);
+	std::string getAccelerationArea() const;
+	void setAccelerationArea(const std::string &accelerationArea);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getVideoCenter() const;
+	void setVideoCenter(const std::string &videoCenter);
+	std::string getAccelerationType() const;
+	void setAccelerationType(const std::string &accelerationType);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+
+private:
+	std::string maxBandwidth_;
+	std::string reuse_;
+	std::string accelerationArea_;
+	std::string appName_;
+	std::string streamName_;
+	std::string domainName_;
+	long ownerId_;
+	std::string videoCenter_;
+	std::string accelerationType_;
+	std::string instanceId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_CREATELIVEPRIVATELINEREQUEST_H_

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

live/include/alibabacloud/live/model/DeleteLivePrivateLineRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DELETELIVEPRIVATELINEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEPRIVATELINEREQUEST_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 DeleteLivePrivateLineRequest : public RpcServiceRequest {
+public:
+	DeleteLivePrivateLineRequest();
+	~DeleteLivePrivateLineRequest();
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getAccelerationType() const;
+	void setAccelerationType(const std::string &accelerationType);
+
+private:
+	std::string appName_;
+	std::string streamName_;
+	std::string domainName_;
+	long ownerId_;
+	std::string accelerationType_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEPRIVATELINEREQUEST_H_

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

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

@@ -40,8 +40,8 @@ namespace AlibabaCloud
 				std::string getApp()const;
 				std::string getTaskTriggerMode()const;
 				std::string getStream()const;
-				std::string getDomain()const;
 				std::string getDelayTime()const;
+				std::string getDomain()const;
 
 			protected:
 				void parse(const std::string &payload);
@@ -49,8 +49,8 @@ namespace AlibabaCloud
 				std::string app_;
 				std::string taskTriggerMode_;
 				std::string stream_;
-				std::string domain_;
 				std::string delayTime_;
+				std::string domain_;
 
 			};
 		}

live/include/alibabacloud/live/model/DescribeLiveGrtnTrafficUsageResult.h

@@ -45,8 +45,8 @@ namespace AlibabaCloud
 				std::vector<UsageData> getUsageDataPerInterval()const;
 				std::string getArea()const;
 				std::string getFiled()const;
-				std::string getEndTime()const;
 				std::string getAppId()const;
+				std::string getEndTime()const;
 				std::string getStartTime()const;
 
 			protected:
@@ -55,8 +55,8 @@ namespace AlibabaCloud
 				std::vector<UsageData> usageDataPerInterval_;
 				std::string area_;
 				std::string filed_;
-				std::string endTime_;
 				std::string appId_;
+				std::string endTime_;
 				std::string startTime_;
 
 			};

live/include/alibabacloud/live/model/DescribeLivePrivateLineAreasRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_DESCRIBELIVEPRIVATELINEAREASREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAREASREQUEST_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 DescribeLivePrivateLineAreasRequest : public RpcServiceRequest {
+public:
+	DescribeLivePrivateLineAreasRequest();
+	~DescribeLivePrivateLineAreasRequest();
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string domainName_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAREASREQUEST_H_

live/include/alibabacloud/live/model/DescribeLivePrivateLineAreasResult.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_DESCRIBELIVEPRIVATELINEAREASRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAREASRESULT_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 DescribeLivePrivateLineAreasResult : public ServiceResult
+			{
+			public:
+				struct LiveArea
+				{
+					struct Region
+					{
+						std::string regionId;
+						std::string localName;
+					};
+					std::string regionType;
+					std::vector<LiveArea::Region> regions;
+				};
+
+
+				DescribeLivePrivateLineAreasResult();
+				explicit DescribeLivePrivateLineAreasResult(const std::string &payload);
+				~DescribeLivePrivateLineAreasResult();
+				std::vector<LiveArea> getLiveAreasList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<LiveArea> liveAreasList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAREASRESULT_H_

live/include/alibabacloud/live/model/DescribeLivePrivateLineAvailGARequest.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_DESCRIBELIVEPRIVATELINEAVAILGAREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAVAILGAREQUEST_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 DescribeLivePrivateLineAvailGARequest : public RpcServiceRequest {
+public:
+	DescribeLivePrivateLineAvailGARequest();
+	~DescribeLivePrivateLineAvailGARequest();
+	std::string getAccelerationArea() const;
+	void setAccelerationArea(const std::string &accelerationArea);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getVideoCenter() const;
+	void setVideoCenter(const std::string &videoCenter);
+	std::string getIsGaInstance() const;
+	void setIsGaInstance(const std::string &isGaInstance);
+
+private:
+	std::string accelerationArea_;
+	std::string appName_;
+	std::string streamName_;
+	std::string domainName_;
+	long ownerId_;
+	std::string videoCenter_;
+	std::string isGaInstance_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAVAILGAREQUEST_H_

live/include/alibabacloud/live/model/DescribeLivePrivateLineAvailGAResult.h

@@ -0,0 +1,65 @@
+/*
+ * 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_DESCRIBELIVEPRIVATELINEAVAILGARESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAVAILGARESULT_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 DescribeLivePrivateLineAvailGAResult : public ServiceResult
+			{
+			public:
+				struct LivePrivateLineAvailGA
+				{
+					std::string status;
+					std::string videoCenter;
+					std::string uid;
+					std::string streamName;
+					std::string accelerationType;
+					std::string domainName;
+					std::string instanceId;
+					std::string bindingStatus;
+					std::string iP;
+					std::string accelerationArea;
+					std::string appName;
+				};
+
+
+				DescribeLivePrivateLineAvailGAResult();
+				explicit DescribeLivePrivateLineAvailGAResult(const std::string &payload);
+				~DescribeLivePrivateLineAvailGAResult();
+				std::vector<LivePrivateLineAvailGA> getLivePrivateLineAvailGAs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<LivePrivateLineAvailGA> livePrivateLineAvailGAs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEPRIVATELINEAVAILGARESULT_H_

live/include/alibabacloud/live/model/DescribeLiveStreamMergeRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMMERGEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMMERGEREQUEST_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 DescribeLiveStreamMergeRequest : public RpcServiceRequest {
+public:
+	DescribeLiveStreamMergeRequest();
+	~DescribeLiveStreamMergeRequest();
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+	std::string getStreamName() const;
+	void setStreamName(const std::string &streamName);
+	std::string getDomainName() const;
+	void setDomainName(const std::string &domainName);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string protocol_;
+	std::string appName_;
+	std::string streamName_;
+	std::string domainName_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMMERGEREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveStreamMergeResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_DESCRIBELIVESTREAMMERGERESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMMERGERESULT_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 DescribeLiveStreamMergeResult : public ServiceResult
+			{
+			public:
+				struct LiveStreamMerge
+				{
+					std::string endTime;
+					std::string domainName;
+					std::string inStreamName1;
+					std::string inStreamName2;
+					std::string startTime;
+					std::string appUsing;
+					std::string appName;
+					std::string streamName;
+					std::string extraInAppStreams;
+					std::string streamUsing;
+					std::string inAppName1;
+					std::string protocol;
+					std::string inAppName2;
+				};
+
+
+				DescribeLiveStreamMergeResult();
+				explicit DescribeLiveStreamMergeResult(const std::string &payload);
+				~DescribeLiveStreamMergeResult();
+				std::vector<LiveStreamMerge> getLiveStreamMergeList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<LiveStreamMerge> liveStreamMergeList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMMERGERESULT_H_

live/include/alibabacloud/live/model/DescribeMeterLiveBypassDurationRequest.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_DESCRIBEMETERLIVEBYPASSDURATIONREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBEMETERLIVEBYPASSDURATIONREQUEST_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 DescribeMeterLiveBypassDurationRequest : public RpcServiceRequest {
+public:
+	DescribeMeterLiveBypassDurationRequest();
+	~DescribeMeterLiveBypassDurationRequest();
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getAppId() const;
+	void setAppId(const std::string &appId);
+	std::string getInterval() const;
+	void setInterval(const std::string &interval);
+
+private:
+	std::string endTime_;
+	std::string startTime_;
+	std::string appId_;
+	std::string interval_;
+};
+} // namespace Model
+} // namespace Live
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBEMETERLIVEBYPASSDURATIONREQUEST_H_

live/include/alibabacloud/live/model/DescribeMeterLiveBypassDurationResult.h

@@ -0,0 +1,76 @@
+/*
+ * 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_DESCRIBEMETERLIVEBYPASSDURATIONRESULT_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBEMETERLIVEBYPASSDURATIONRESULT_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 DescribeMeterLiveBypassDurationResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					long single_Audio;
+					long v720Duration;
+					long v1080Duration;
+					long v480Duration;
+					std::string timestamp;
+					long audioDuration;
+					long single_Video;
+					long totalDuration;
+				};
+
+
+				DescribeMeterLiveBypassDurationResult();
+				explicit DescribeMeterLiveBypassDurationResult(const std::string &payload);
+				~DescribeMeterLiveBypassDurationResult();
+				long getV480SummaryDuration()const;
+				long getV1080SummaryDuration()const;
+				long getV720SummaryDuration()const;
+				std::vector<DataItem> getData()const;
+				long getAudioSummaryDuration()const;
+				long getTotalSummaryDuration()const;
+				long getSingleAudioSummaryDuration()const;
+				long getSingleVideoSummaryDuration()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long v480SummaryDuration_;
+				long v1080SummaryDuration_;
+				long v720SummaryDuration_;
+				std::vector<DataItem> data_;
+				long audioSummaryDuration_;
+				long totalSummaryDuration_;
+				long singleAudioSummaryDuration_;
+				long singleVideoSummaryDuration_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBEMETERLIVEBYPASSDURATIONRESULT_H_

live/include/alibabacloud/live/model/DescribeMeterLiveRtcDurationResult.h

@@ -38,8 +38,8 @@ namespace AlibabaCloud
 					long v1080Duration;
 					long v480Duration;
 					std::string timestamp;
-					long totalDuration;
 					long audioDuration;
+					long totalDuration;
 				};
 
 
@@ -50,8 +50,8 @@ namespace AlibabaCloud
 				long getV1080SummaryDuration()const;
 				long getV720SummaryDuration()const;
 				std::vector<DataItem> getData()const;
-				long getTotalSummaryDuration()const;
 				long getAudioSummaryDuration()const;
+				long getTotalSummaryDuration()const;
 
 			protected:
 				void parse(const std::string &payload);
@@ -60,8 +60,8 @@ namespace AlibabaCloud
 				long v1080SummaryDuration_;
 				long v720SummaryDuration_;
 				std::vector<DataItem> data_;
-				long totalSummaryDuration_;
 				long audioSummaryDuration_;
+				long totalSummaryDuration_;
 
 			};
 		}

live/include/alibabacloud/live/model/DescribeShowListResult.h

@@ -50,9 +50,9 @@ namespace AlibabaCloud
 						std::string showName;
 					};
 					std::string currentShowId;
+					std::string highPriorityShowId;
 					std::string highPriorityShowStartTime;
 					int totalShowListRepeatTimes;
-					std::string highPriorityShowId;
 					int showListRepeatTimes;
 					std::vector<Show> showList;
 				};

live/include/alibabacloud/live/model/GetEdgeTranscodeTemplateResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct _Template
 				{
-					std::string type;
 					std::string codec;
+					std::string type;
 					std::string createTime;
 					std::string fps;
 					std::string gop;

live/include/alibabacloud/live/model/GetMessageAppResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct Result
 				{
-					int status;
 					std::string extension;
+					int status;
 					std::string appConfig;
 					std::string appId;
 					long createTime;

live/include/alibabacloud/live/model/GetMessageGroupResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct Result
 				{
-					int status;
 					std::string extension;
+					int status;
 					std::string creatorId;
 					long createTime;
 					bool isMuteAll;

live/include/alibabacloud/live/model/ListEdgeTranscodeTemplateResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct _Template
 				{
-					std::string type;
 					std::string codec;
+					std::string type;
 					std::string createTime;
 					std::string fps;
 					std::string gop;

live/include/alibabacloud/live/model/ListLiveMessageGroupsRequest.h

@@ -32,6 +32,8 @@ public:
 	~ListLiveMessageGroupsRequest();
 	int getSortType() const;
 	void setSortType(int sortType);
+	int getGroupStatus() const;
+	void setGroupStatus(int groupStatus);
 	long getNextPageToken() const;
 	void setNextPageToken(long nextPageToken);
 	std::string getDataCenter() const;
@@ -41,6 +43,7 @@ public:
 
 private:
 	int sortType_;
+	int groupStatus_;
 	long nextPageToken_;
 	std::string dataCenter_;
 	std::string appId_;

live/include/alibabacloud/live/model/ListMessageAppResult.h

@@ -36,8 +36,8 @@ namespace AlibabaCloud
 				{
 					struct AppListItem
 					{
-						int status;
 						std::string extension;
+						int status;
 						std::string appConfig;
 						std::string appId;
 						long createTime;

live/include/alibabacloud/live/model/ListMessageGroupResult.h

@@ -36,8 +36,8 @@ namespace AlibabaCloud
 				{
 					struct GroupListItem
 					{
-						int status;
 						std::string extension;
+						int status;
 						std::string appId;
 						std::string creatorId;
 						long createTime;

live/include/alibabacloud/live/model/ListMessageGroupUserByIdResult.h

@@ -38,8 +38,8 @@ namespace AlibabaCloud
 					{
 						std::string userAvatar;
 						std::string userId;
-						std::string userExtension;
 						bool isMute;
+						std::string userExtension;
 						std::string userNick;
 						std::vector<std::string> muteBy;
 					};

live/include/alibabacloud/live/model/ModifyLiveMessageUserInfoResult.h

@@ -32,16 +32,16 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_LIVE_EXPORT ModifyLiveMessageUserInfoResult : public ServiceResult
 			{
 			public:
-				struct SuccessGroups
+				struct FailGroups
 				{
+					int code;
+					std::string reason;
 					bool success;
 					std::string groupId;
 				};
-				struct FailGroups
+				struct SuccessGroups
 				{
-					int code;
 					bool success;
-					std::string reason;
 					std::string groupId;
 				};
 

live/include/alibabacloud/live/model/QueryMessageAppResult.h

@@ -36,8 +36,8 @@ namespace AlibabaCloud
 				{
 					struct AppListItem
 					{
-						int status;
 						std::string extension;
+						int status;
 						std::string appConfig;
 						std::string appId;
 						long createTime;

live/include/alibabacloud/live/model/StartLiveMPUTaskRequest.h

@@ -53,15 +53,15 @@ public:
 			struct UserPanesItem {
 				std::string backgroundImageUrl;
 				std::string zOrder;
-				std::string x;
 				std::string width;
+				std::string x;
 				std::string y;
+				std::string renderMode;
 				struct UserInfo {
 					std::string sourceType;
 					std::string userId;
 				};
 				UserInfo userInfo;
-				std::string renderMode;
 				std::string height;
 			};
 			UserPanesItem userPanesItem;
@@ -76,8 +76,8 @@ public:
 		};
 		Layout layout;
 		struct Background {
-			std::string uRL;
 			std::string renderMode;
+			std::string uRL;
 		};
 		Background background;
 		struct UserInfosItem {
@@ -93,10 +93,10 @@ public:
 			std::string audioBitrate;
 			std::string videoFramerate;
 			std::string videoHeight;
-			std::string videoBitrate;
 			std::string audioSampleRate;
-			std::string videoGop;
+			std::string videoBitrate;
 			std::string audioChannels;
+			std::string videoGop;
 		};
 		EncodeParams encodeParams;
 	};

live/include/alibabacloud/live/model/UpdateLiveMPUTaskRequest.h

@@ -52,15 +52,15 @@ public:
 			struct UserPanesItem {
 				std::string backgroundImageUrl;
 				std::string zOrder;
-				std::string x;
 				std::string width;
+				std::string x;
 				std::string y;
+				std::string renderMode;
 				struct UserInfo {
 					std::string sourceType;
 					std::string userId;
 				};
 				UserInfo userInfo;
-				std::string renderMode;
 				std::string height;
 			};
 			UserPanesItem userPanesItem;
@@ -75,8 +75,8 @@ public:
 		};
 		Layout layout;
 		struct Background {
-			std::string uRL;
 			std::string renderMode;
+			std::string uRL;
 		};
 		Background background;
 		struct UserInfosItem {
@@ -92,10 +92,10 @@ public:
 			std::string audioBitrate;
 			std::string videoFramerate;
 			std::string videoHeight;
-			std::string videoBitrate;
 			std::string audioSampleRate;
-			std::string videoGop;
+			std::string videoBitrate;
 			std::string audioChannels;
+			std::string videoGop;
 		};
 		EncodeParams encodeParams;
 	};

live/src/LiveClient.cc

@@ -1887,6 +1887,42 @@ LiveClient::CreateLiveMessageGroupOutcomeCallable LiveClient::createLiveMessageG
 	return task->get_future();
 }
 
+LiveClient::CreateLivePrivateLineOutcome LiveClient::createLivePrivateLine(const CreateLivePrivateLineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateLivePrivateLineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateLivePrivateLineOutcome(CreateLivePrivateLineResult(outcome.result()));
+	else
+		return CreateLivePrivateLineOutcome(outcome.error());
+}
+
+void LiveClient::createLivePrivateLineAsync(const CreateLivePrivateLineRequest& request, const CreateLivePrivateLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createLivePrivateLine(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::CreateLivePrivateLineOutcomeCallable LiveClient::createLivePrivateLineCallable(const CreateLivePrivateLineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateLivePrivateLineOutcome()>>(
+			[this, request]()
+			{
+			return this->createLivePrivateLine(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::CreateLiveRealTimeLogDeliveryOutcome LiveClient::createLiveRealTimeLogDelivery(const CreateLiveRealTimeLogDeliveryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,6 +3219,42 @@ LiveClient::DeleteLivePackageConfigOutcomeCallable LiveClient::deleteLivePackage
 	return task->get_future();
 }
 
+LiveClient::DeleteLivePrivateLineOutcome LiveClient::deleteLivePrivateLine(const DeleteLivePrivateLineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteLivePrivateLineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteLivePrivateLineOutcome(DeleteLivePrivateLineResult(outcome.result()));
+	else
+		return DeleteLivePrivateLineOutcome(outcome.error());
+}
+
+void LiveClient::deleteLivePrivateLineAsync(const DeleteLivePrivateLineRequest& request, const DeleteLivePrivateLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteLivePrivateLine(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DeleteLivePrivateLineOutcomeCallable LiveClient::deleteLivePrivateLineCallable(const DeleteLivePrivateLineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteLivePrivateLineOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteLivePrivateLine(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DeleteLivePullStreamInfoConfigOutcome LiveClient::deleteLivePullStreamInfoConfig(const DeleteLivePullStreamInfoConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6711,6 +6783,78 @@ LiveClient::DescribeLivePackageConfigOutcomeCallable LiveClient::describeLivePac
 	return task->get_future();
 }
 
+LiveClient::DescribeLivePrivateLineAreasOutcome LiveClient::describeLivePrivateLineAreas(const DescribeLivePrivateLineAreasRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLivePrivateLineAreasOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLivePrivateLineAreasOutcome(DescribeLivePrivateLineAreasResult(outcome.result()));
+	else
+		return DescribeLivePrivateLineAreasOutcome(outcome.error());
+}
+
+void LiveClient::describeLivePrivateLineAreasAsync(const DescribeLivePrivateLineAreasRequest& request, const DescribeLivePrivateLineAreasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLivePrivateLineAreas(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLivePrivateLineAreasOutcomeCallable LiveClient::describeLivePrivateLineAreasCallable(const DescribeLivePrivateLineAreasRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLivePrivateLineAreasOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLivePrivateLineAreas(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LiveClient::DescribeLivePrivateLineAvailGAOutcome LiveClient::describeLivePrivateLineAvailGA(const DescribeLivePrivateLineAvailGARequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLivePrivateLineAvailGAOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLivePrivateLineAvailGAOutcome(DescribeLivePrivateLineAvailGAResult(outcome.result()));
+	else
+		return DescribeLivePrivateLineAvailGAOutcome(outcome.error());
+}
+
+void LiveClient::describeLivePrivateLineAvailGAAsync(const DescribeLivePrivateLineAvailGARequest& request, const DescribeLivePrivateLineAvailGAAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLivePrivateLineAvailGA(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLivePrivateLineAvailGAOutcomeCallable LiveClient::describeLivePrivateLineAvailGACallable(const DescribeLivePrivateLineAvailGARequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLivePrivateLineAvailGAOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLivePrivateLineAvailGA(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveProducerUsageDataOutcome LiveClient::describeLiveProducerUsageData(const DescribeLiveProducerUsageDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -7431,6 +7575,42 @@ LiveClient::DescribeLiveStreamHistoryUserNumOutcomeCallable LiveClient::describe
 	return task->get_future();
 }
 
+LiveClient::DescribeLiveStreamMergeOutcome LiveClient::describeLiveStreamMerge(const DescribeLiveStreamMergeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLiveStreamMergeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLiveStreamMergeOutcome(DescribeLiveStreamMergeResult(outcome.result()));
+	else
+		return DescribeLiveStreamMergeOutcome(outcome.error());
+}
+
+void LiveClient::describeLiveStreamMergeAsync(const DescribeLiveStreamMergeRequest& request, const DescribeLiveStreamMergeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLiveStreamMerge(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeLiveStreamMergeOutcomeCallable LiveClient::describeLiveStreamMergeCallable(const DescribeLiveStreamMergeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLiveStreamMergeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLiveStreamMerge(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeLiveStreamMetricDetailDataOutcome LiveClient::describeLiveStreamMetricDetailData(const DescribeLiveStreamMetricDetailDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -8439,6 +8619,42 @@ LiveClient::DescribeLiveUserTagsOutcomeCallable LiveClient::describeLiveUserTags
 	return task->get_future();
 }
 
+LiveClient::DescribeMeterLiveBypassDurationOutcome LiveClient::describeMeterLiveBypassDuration(const DescribeMeterLiveBypassDurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeMeterLiveBypassDurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeMeterLiveBypassDurationOutcome(DescribeMeterLiveBypassDurationResult(outcome.result()));
+	else
+		return DescribeMeterLiveBypassDurationOutcome(outcome.error());
+}
+
+void LiveClient::describeMeterLiveBypassDurationAsync(const DescribeMeterLiveBypassDurationRequest& request, const DescribeMeterLiveBypassDurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeMeterLiveBypassDuration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LiveClient::DescribeMeterLiveBypassDurationOutcomeCallable LiveClient::describeMeterLiveBypassDurationCallable(const DescribeMeterLiveBypassDurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeMeterLiveBypassDurationOutcome()>>(
+			[this, request]()
+			{
+			return this->describeMeterLiveBypassDuration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 LiveClient::DescribeMeterLiveInteractionDauOutcome LiveClient::describeMeterLiveInteractionDau(const DescribeMeterLiveInteractionDauRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

live/src/model/BatchGetOnlineUsersResult.cc

@@ -44,12 +44,12 @@ void BatchGetOnlineUsersResult::parse(const std::string &payload)
 	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";
+		if(!resultNodeOnlineUsersonlineUsersItem["UserId"].isNull())
+			onlineUsersItemObject.userId = resultNodeOnlineUsersonlineUsersItem["UserId"].asString();
 		result_.onlineUsers.push_back(onlineUsersItemObject);
 	}
 

live/src/model/CheckLiveMessageUsersOnlineResult.cc

@@ -43,10 +43,10 @@ void CheckLiveMessageUsersOnlineResult::parse(const std::string &payload)
 	for (auto valueUserListUsers : allUserListNode)
 	{
 		Users userListObject;
-		if(!valueUserListUsers["UserId"].isNull())
-			userListObject.userId = valueUserListUsers["UserId"].asString();
 		if(!valueUserListUsers["Online"].isNull())
 			userListObject.online = valueUserListUsers["Online"].asString() == "true";
+		if(!valueUserListUsers["UserId"].isNull())
+			userListObject.userId = valueUserListUsers["UserId"].asString();
 		userList_.push_back(userListObject);
 	}
 

live/src/model/CreateLivePrivateLineRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * 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/CreateLivePrivateLineRequest.h>
+
+using AlibabaCloud::Live::Model::CreateLivePrivateLineRequest;
+
+CreateLivePrivateLineRequest::CreateLivePrivateLineRequest()
+    : RpcServiceRequest("live", "2016-11-01", "CreateLivePrivateLine") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateLivePrivateLineRequest::~CreateLivePrivateLineRequest() {}
+
+std::string CreateLivePrivateLineRequest::getMaxBandwidth() const {
+  return maxBandwidth_;
+}
+
+void CreateLivePrivateLineRequest::setMaxBandwidth(const std::string &maxBandwidth) {
+  maxBandwidth_ = maxBandwidth;
+  setParameter(std::string("MaxBandwidth"), maxBandwidth);
+}
+
+std::string CreateLivePrivateLineRequest::getReuse() const {
+  return reuse_;
+}
+
+void CreateLivePrivateLineRequest::setReuse(const std::string &reuse) {
+  reuse_ = reuse;
+  setParameter(std::string("Reuse"), reuse);
+}
+
+std::string CreateLivePrivateLineRequest::getAccelerationArea() const {
+  return accelerationArea_;
+}
+
+void CreateLivePrivateLineRequest::setAccelerationArea(const std::string &accelerationArea) {
+  accelerationArea_ = accelerationArea;
+  setParameter(std::string("AccelerationArea"), accelerationArea);
+}
+
+std::string CreateLivePrivateLineRequest::getAppName() const {
+  return appName_;
+}
+
+void CreateLivePrivateLineRequest::setAppName(const std::string &appName) {
+  appName_ = appName;
+  setParameter(std::string("AppName"), appName);
+}
+
+std::string CreateLivePrivateLineRequest::getStreamName() const {
+  return streamName_;
+}
+
+void CreateLivePrivateLineRequest::setStreamName(const std::string &streamName) {
+  streamName_ = streamName;
+  setParameter(std::string("StreamName"), streamName);
+}
+
+std::string CreateLivePrivateLineRequest::getDomainName() const {
+  return domainName_;
+}
+
+void CreateLivePrivateLineRequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+long CreateLivePrivateLineRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateLivePrivateLineRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateLivePrivateLineRequest::getVideoCenter() const {
+  return videoCenter_;
+}
+
+void CreateLivePrivateLineRequest::setVideoCenter(const std::string &videoCenter) {
+  videoCenter_ = videoCenter;
+  setParameter(std::string("VideoCenter"), videoCenter);
+}
+
+std::string CreateLivePrivateLineRequest::getAccelerationType() const {
+  return accelerationType_;
+}
+
+void CreateLivePrivateLineRequest::setAccelerationType(const std::string &accelerationType) {
+  accelerationType_ = accelerationType;
+  setParameter(std::string("AccelerationType"), accelerationType);
+}
+
+std::string CreateLivePrivateLineRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CreateLivePrivateLineRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+

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

live/src/model/CreateMessageGroupResult.cc

@@ -40,10 +40,10 @@ void CreateMessageGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["GroupId"].isNull())
-		result_.groupId = resultNode["GroupId"].asString();
 	if(!resultNode["Extension"].isNull())
 		result_.extension = resultNode["Extension"].asString();
+	if(!resultNode["GroupId"].isNull())
+		result_.groupId = resultNode["GroupId"].asString();
 
 }
 

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

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

live/src/model/DescribeChannelParticipantsResult.cc

@@ -42,12 +42,12 @@ void DescribeChannelParticipantsResult::parse(const std::string &payload)
 	auto allUserList = value["UserList"]["Users"];
 	for (const auto &item : allUserList)
 		userList_.push_back(item.asString());
-	if(!value["TotalPage"].isNull())
-		totalPage_ = std::stoi(value["TotalPage"].asString());
-	if(!value["TotalNum"].isNull())
-		totalNum_ = std::stoi(value["TotalNum"].asString());
 	if(!value["Times"].isNull())
 		times_ = std::stol(value["Times"].asString());
+	if(!value["TotalNum"].isNull())
+		totalNum_ = std::stoi(value["TotalNum"].asString());
+	if(!value["TotalPage"].isNull())
+		totalPage_ = std::stoi(value["TotalPage"].asString());
 
 }
 

live/src/model/DescribeLiveCenterStreamRateDataResult.cc

@@ -43,16 +43,16 @@ void DescribeLiveCenterStreamRateDataResult::parse(const std::string &payload)
 	for (auto valueRateDatasData : allRateDatasNode)
 	{
 		Data rateDatasObject;
-		if(!valueRateDatasData["VideoFps"].isNull())
-			rateDatasObject.videoFps = valueRateDatasData["VideoFps"].asString();
-		if(!valueRateDatasData["VideoRate"].isNull())
-			rateDatasObject.videoRate = valueRateDatasData["VideoRate"].asString();
 		if(!valueRateDatasData["AudioFps"].isNull())
 			rateDatasObject.audioFps = valueRateDatasData["AudioFps"].asString();
 		if(!valueRateDatasData["AudioRate"].isNull())
 			rateDatasObject.audioRate = valueRateDatasData["AudioRate"].asString();
 		if(!valueRateDatasData["Time"].isNull())
 			rateDatasObject.time = valueRateDatasData["Time"].asString();
+		if(!valueRateDatasData["VideoFps"].isNull())
+			rateDatasObject.videoFps = valueRateDatasData["VideoFps"].asString();
+		if(!valueRateDatasData["VideoRate"].isNull())
+			rateDatasObject.videoRate = valueRateDatasData["VideoRate"].asString();
 		rateDatas_.push_back(rateDatasObject);
 	}
 

live/src/model/DescribeLiveDelayConfigResult.cc

@@ -39,16 +39,16 @@ void DescribeLiveDelayConfigResult::parse(const std::string &payload)
 	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["Domain"].isNull())
+		domain_ = value["Domain"].asString();
 	if(!value["Stream"].isNull())
 		stream_ = value["Stream"].asString();
+	if(!value["TaskTriggerMode"].isNull())
+		taskTriggerMode_ = value["TaskTriggerMode"].asString();
 
 }
 
@@ -67,13 +67,13 @@ std::string DescribeLiveDelayConfigResult::getStream()const
 	return stream_;
 }
 
-std::string DescribeLiveDelayConfigResult::getDomain()const
+std::string DescribeLiveDelayConfigResult::getDelayTime()const
 {
-	return domain_;
+	return delayTime_;
 }
 
-std::string DescribeLiveDelayConfigResult::getDelayTime()const
+std::string DescribeLiveDelayConfigResult::getDomain()const
 {
-	return delayTime_;
+	return domain_;
 }
 

live/src/model/DescribeLiveDomainEdgeLogResult.cc

@@ -51,14 +51,14 @@ void DescribeLiveDomainEdgeLogResult::parse(const std::string &payload)
 			DomainLogDetail::LogInfoDetail logInfosObject;
 			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["EndTime"].isNull())
 				logInfosObject.endTime = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["EndTime"].asString();
-			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogSize"].isNull())
-				logInfosObject.logSize = std::stol(valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogSize"].asString());
-			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["StartTime"].isNull())
-				logInfosObject.startTime = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["StartTime"].asString();
 			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogName"].isNull())
 				logInfosObject.logName = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogName"].asString();
 			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogPath"].isNull())
 				logInfosObject.logPath = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogPath"].asString();
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogSize"].isNull())
+				logInfosObject.logSize = std::stol(valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["LogSize"].asString());
+			if(!valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["StartTime"].isNull())
+				logInfosObject.startTime = valueDomainLogDetailsDomainLogDetailLogInfosLogInfoDetail["StartTime"].asString();
 			domainLogDetailsObject.logInfos.push_back(logInfosObject);
 		}
 		auto pageInfosNode = value["PageInfos"];

live/src/model/DescribeLiveGrtnTrafficUsageResult.cc

@@ -43,22 +43,22 @@ void DescribeLiveGrtnTrafficUsageResult::parse(const std::string &payload)
 	for (auto valueUsageDataPerIntervalUsageData : allUsageDataPerIntervalNode)
 	{
 		UsageData usageDataPerIntervalObject;
-		if(!valueUsageDataPerIntervalUsageData["Value"].isNull())
-			usageDataPerIntervalObject.value = valueUsageDataPerIntervalUsageData["Value"].asString();
 		if(!valueUsageDataPerIntervalUsageData["TimeStamp"].isNull())
 			usageDataPerIntervalObject.timeStamp = valueUsageDataPerIntervalUsageData["TimeStamp"].asString();
+		if(!valueUsageDataPerIntervalUsageData["Value"].isNull())
+			usageDataPerIntervalObject.value = valueUsageDataPerIntervalUsageData["Value"].asString();
 		usageDataPerInterval_.push_back(usageDataPerIntervalObject);
 	}
-	if(!value["EndTime"].isNull())
-		endTime_ = value["EndTime"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
-	if(!value["Filed"].isNull())
-		filed_ = value["Filed"].asString();
 	if(!value["AppId"].isNull())
 		appId_ = value["AppId"].asString();
 	if(!value["Area"].isNull())
 		area_ = value["Area"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["Filed"].isNull())
+		filed_ = value["Filed"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 
@@ -77,14 +77,14 @@ std::string DescribeLiveGrtnTrafficUsageResult::getFiled()const
 	return filed_;
 }
 
-std::string DescribeLiveGrtnTrafficUsageResult::getEndTime()const
+std::string DescribeLiveGrtnTrafficUsageResult::getAppId()const
 {
-	return endTime_;
+	return appId_;
 }
 
-std::string DescribeLiveGrtnTrafficUsageResult::getAppId()const
+std::string DescribeLiveGrtnTrafficUsageResult::getEndTime()const
 {
-	return appId_;
+	return endTime_;
 }
 
 std::string DescribeLiveGrtnTrafficUsageResult::getStartTime()const

live/src/model/DescribeLivePrivateLineAreasRequest.cc

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

live/src/model/DescribeLivePrivateLineAreasResult.cc

@@ -0,0 +1,67 @@
+/*
+ * 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/DescribeLivePrivateLineAreasResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLivePrivateLineAreasResult::DescribeLivePrivateLineAreasResult() :
+	ServiceResult()
+{}
+
+DescribeLivePrivateLineAreasResult::DescribeLivePrivateLineAreasResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLivePrivateLineAreasResult::~DescribeLivePrivateLineAreasResult()
+{}
+
+void DescribeLivePrivateLineAreasResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLiveAreasListNode = value["LiveAreasList"]["LiveArea"];
+	for (auto valueLiveAreasListLiveArea : allLiveAreasListNode)
+	{
+		LiveArea liveAreasListObject;
+		if(!valueLiveAreasListLiveArea["RegionType"].isNull())
+			liveAreasListObject.regionType = valueLiveAreasListLiveArea["RegionType"].asString();
+		auto allRegionsNode = valueLiveAreasListLiveArea["Regions"]["Region"];
+		for (auto valueLiveAreasListLiveAreaRegionsRegion : allRegionsNode)
+		{
+			LiveArea::Region regionsObject;
+			if(!valueLiveAreasListLiveAreaRegionsRegion["LocalName"].isNull())
+				regionsObject.localName = valueLiveAreasListLiveAreaRegionsRegion["LocalName"].asString();
+			if(!valueLiveAreasListLiveAreaRegionsRegion["RegionId"].isNull())
+				regionsObject.regionId = valueLiveAreasListLiveAreaRegionsRegion["RegionId"].asString();
+			liveAreasListObject.regions.push_back(regionsObject);
+		}
+		liveAreasList_.push_back(liveAreasListObject);
+	}
+
+}
+
+std::vector<DescribeLivePrivateLineAreasResult::LiveArea> DescribeLivePrivateLineAreasResult::getLiveAreasList()const
+{
+	return liveAreasList_;
+}
+

live/src/model/DescribeLivePrivateLineAvailGARequest.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/DescribeLivePrivateLineAvailGARequest.h>
+
+using AlibabaCloud::Live::Model::DescribeLivePrivateLineAvailGARequest;
+
+DescribeLivePrivateLineAvailGARequest::DescribeLivePrivateLineAvailGARequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeLivePrivateLineAvailGA") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLivePrivateLineAvailGARequest::~DescribeLivePrivateLineAvailGARequest() {}
+
+std::string DescribeLivePrivateLineAvailGARequest::getAccelerationArea() const {
+  return accelerationArea_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setAccelerationArea(const std::string &accelerationArea) {
+  accelerationArea_ = accelerationArea;
+  setParameter(std::string("AccelerationArea"), accelerationArea);
+}
+
+std::string DescribeLivePrivateLineAvailGARequest::getAppName() const {
+  return appName_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setAppName(const std::string &appName) {
+  appName_ = appName;
+  setParameter(std::string("AppName"), appName);
+}
+
+std::string DescribeLivePrivateLineAvailGARequest::getStreamName() const {
+  return streamName_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setStreamName(const std::string &streamName) {
+  streamName_ = streamName;
+  setParameter(std::string("StreamName"), streamName);
+}
+
+std::string DescribeLivePrivateLineAvailGARequest::getDomainName() const {
+  return domainName_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setDomainName(const std::string &domainName) {
+  domainName_ = domainName;
+  setParameter(std::string("DomainName"), domainName);
+}
+
+long DescribeLivePrivateLineAvailGARequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeLivePrivateLineAvailGARequest::getVideoCenter() const {
+  return videoCenter_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setVideoCenter(const std::string &videoCenter) {
+  videoCenter_ = videoCenter;
+  setParameter(std::string("VideoCenter"), videoCenter);
+}
+
+std::string DescribeLivePrivateLineAvailGARequest::getIsGaInstance() const {
+  return isGaInstance_;
+}
+
+void DescribeLivePrivateLineAvailGARequest::setIsGaInstance(const std::string &isGaInstance) {
+  isGaInstance_ = isGaInstance;
+  setParameter(std::string("IsGaInstance"), isGaInstance);
+}
+

live/src/model/DescribeLivePrivateLineAvailGAResult.cc

@@ -0,0 +1,77 @@
+/*
+ * 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/DescribeLivePrivateLineAvailGAResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLivePrivateLineAvailGAResult::DescribeLivePrivateLineAvailGAResult() :
+	ServiceResult()
+{}
+
+DescribeLivePrivateLineAvailGAResult::DescribeLivePrivateLineAvailGAResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLivePrivateLineAvailGAResult::~DescribeLivePrivateLineAvailGAResult()
+{}
+
+void DescribeLivePrivateLineAvailGAResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLivePrivateLineAvailGAsNode = value["LivePrivateLineAvailGAs"]["LivePrivateLineAvailGA"];
+	for (auto valueLivePrivateLineAvailGAsLivePrivateLineAvailGA : allLivePrivateLineAvailGAsNode)
+	{
+		LivePrivateLineAvailGA livePrivateLineAvailGAsObject;
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["AccelerationArea"].isNull())
+			livePrivateLineAvailGAsObject.accelerationArea = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["AccelerationArea"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["AccelerationType"].isNull())
+			livePrivateLineAvailGAsObject.accelerationType = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["AccelerationType"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["AppName"].isNull())
+			livePrivateLineAvailGAsObject.appName = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["AppName"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["BindingStatus"].isNull())
+			livePrivateLineAvailGAsObject.bindingStatus = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["BindingStatus"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["DomainName"].isNull())
+			livePrivateLineAvailGAsObject.domainName = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["DomainName"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["IP"].isNull())
+			livePrivateLineAvailGAsObject.iP = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["IP"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["InstanceId"].isNull())
+			livePrivateLineAvailGAsObject.instanceId = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["InstanceId"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["Status"].isNull())
+			livePrivateLineAvailGAsObject.status = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["Status"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["StreamName"].isNull())
+			livePrivateLineAvailGAsObject.streamName = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["StreamName"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["Uid"].isNull())
+			livePrivateLineAvailGAsObject.uid = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["Uid"].asString();
+		if(!valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["VideoCenter"].isNull())
+			livePrivateLineAvailGAsObject.videoCenter = valueLivePrivateLineAvailGAsLivePrivateLineAvailGA["VideoCenter"].asString();
+		livePrivateLineAvailGAs_.push_back(livePrivateLineAvailGAsObject);
+	}
+
+}
+
+std::vector<DescribeLivePrivateLineAvailGAResult::LivePrivateLineAvailGA> DescribeLivePrivateLineAvailGAResult::getLivePrivateLineAvailGAs()const
+{
+	return livePrivateLineAvailGAs_;
+}
+

live/src/model/DescribeLiveStreamDetailFrameRateAndBitRateDataResult.cc

@@ -43,20 +43,20 @@ void DescribeLiveStreamDetailFrameRateAndBitRateDataResult::parse(const std::str
 	for (auto valueFrameRateAndBitRateInfosfrabr : allFrameRateAndBitRateInfosNode)
 	{
 		Frabr frameRateAndBitRateInfosObject;
-		if(!valueFrameRateAndBitRateInfosfrabr["Time"].isNull())
-			frameRateAndBitRateInfosObject.time = valueFrameRateAndBitRateInfosfrabr["Time"].asString();
-		if(!valueFrameRateAndBitRateInfosfrabr["VideoFrameRate"].isNull())
-			frameRateAndBitRateInfosObject.videoFrameRate = std::stof(valueFrameRateAndBitRateInfosfrabr["VideoFrameRate"].asString());
+		if(!valueFrameRateAndBitRateInfosfrabr["AudioBitRate"].isNull())
+			frameRateAndBitRateInfosObject.audioBitRate = std::stof(valueFrameRateAndBitRateInfosfrabr["AudioBitRate"].asString());
 		if(!valueFrameRateAndBitRateInfosfrabr["AudioFrameRate"].isNull())
 			frameRateAndBitRateInfosObject.audioFrameRate = std::stof(valueFrameRateAndBitRateInfosfrabr["AudioFrameRate"].asString());
-		if(!valueFrameRateAndBitRateInfosfrabr["StreamUrl"].isNull())
-			frameRateAndBitRateInfosObject.streamUrl = valueFrameRateAndBitRateInfosfrabr["StreamUrl"].asString();
 		if(!valueFrameRateAndBitRateInfosfrabr["BitRate"].isNull())
 			frameRateAndBitRateInfosObject.bitRate = std::stof(valueFrameRateAndBitRateInfosfrabr["BitRate"].asString());
+		if(!valueFrameRateAndBitRateInfosfrabr["StreamUrl"].isNull())
+			frameRateAndBitRateInfosObject.streamUrl = valueFrameRateAndBitRateInfosfrabr["StreamUrl"].asString();
+		if(!valueFrameRateAndBitRateInfosfrabr["Time"].isNull())
+			frameRateAndBitRateInfosObject.time = valueFrameRateAndBitRateInfosfrabr["Time"].asString();
 		if(!valueFrameRateAndBitRateInfosfrabr["VideoBitRate"].isNull())
 			frameRateAndBitRateInfosObject.videoBitRate = std::stof(valueFrameRateAndBitRateInfosfrabr["VideoBitRate"].asString());
-		if(!valueFrameRateAndBitRateInfosfrabr["AudioBitRate"].isNull())
-			frameRateAndBitRateInfosObject.audioBitRate = std::stof(valueFrameRateAndBitRateInfosfrabr["AudioBitRate"].asString());
+		if(!valueFrameRateAndBitRateInfosfrabr["VideoFrameRate"].isNull())
+			frameRateAndBitRateInfosObject.videoFrameRate = std::stof(valueFrameRateAndBitRateInfosfrabr["VideoFrameRate"].asString());
 		frameRateAndBitRateInfos_.push_back(frameRateAndBitRateInfosObject);
 	}
 

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

live/src/model/DescribeLiveStreamMergeResult.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/DescribeLiveStreamMergeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveStreamMergeResult::DescribeLiveStreamMergeResult() :
+	ServiceResult()
+{}
+
+DescribeLiveStreamMergeResult::DescribeLiveStreamMergeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveStreamMergeResult::~DescribeLiveStreamMergeResult()
+{}
+
+void DescribeLiveStreamMergeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLiveStreamMergeListNode = value["LiveStreamMergeList"]["LiveStreamMerge"];
+	for (auto valueLiveStreamMergeListLiveStreamMerge : allLiveStreamMergeListNode)
+	{
+		LiveStreamMerge liveStreamMergeListObject;
+		if(!valueLiveStreamMergeListLiveStreamMerge["AppName"].isNull())
+			liveStreamMergeListObject.appName = valueLiveStreamMergeListLiveStreamMerge["AppName"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["AppUsing"].isNull())
+			liveStreamMergeListObject.appUsing = valueLiveStreamMergeListLiveStreamMerge["AppUsing"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["DomainName"].isNull())
+			liveStreamMergeListObject.domainName = valueLiveStreamMergeListLiveStreamMerge["DomainName"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["EndTime"].isNull())
+			liveStreamMergeListObject.endTime = valueLiveStreamMergeListLiveStreamMerge["EndTime"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["ExtraInAppStreams"].isNull())
+			liveStreamMergeListObject.extraInAppStreams = valueLiveStreamMergeListLiveStreamMerge["ExtraInAppStreams"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["InAppName1"].isNull())
+			liveStreamMergeListObject.inAppName1 = valueLiveStreamMergeListLiveStreamMerge["InAppName1"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["InAppName2"].isNull())
+			liveStreamMergeListObject.inAppName2 = valueLiveStreamMergeListLiveStreamMerge["InAppName2"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["InStreamName1"].isNull())
+			liveStreamMergeListObject.inStreamName1 = valueLiveStreamMergeListLiveStreamMerge["InStreamName1"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["InStreamName2"].isNull())
+			liveStreamMergeListObject.inStreamName2 = valueLiveStreamMergeListLiveStreamMerge["InStreamName2"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["Protocol"].isNull())
+			liveStreamMergeListObject.protocol = valueLiveStreamMergeListLiveStreamMerge["Protocol"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["StartTime"].isNull())
+			liveStreamMergeListObject.startTime = valueLiveStreamMergeListLiveStreamMerge["StartTime"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["StreamName"].isNull())
+			liveStreamMergeListObject.streamName = valueLiveStreamMergeListLiveStreamMerge["StreamName"].asString();
+		if(!valueLiveStreamMergeListLiveStreamMerge["StreamUsing"].isNull())
+			liveStreamMergeListObject.streamUsing = valueLiveStreamMergeListLiveStreamMerge["StreamUsing"].asString();
+		liveStreamMergeList_.push_back(liveStreamMergeListObject);
+	}
+
+}
+
+std::vector<DescribeLiveStreamMergeResult::LiveStreamMerge> DescribeLiveStreamMergeResult::getLiveStreamMergeList()const
+{
+	return liveStreamMergeList_;
+}
+

live/src/model/DescribeMeterLiveBypassDurationRequest.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/DescribeMeterLiveBypassDurationRequest.h>
+
+using AlibabaCloud::Live::Model::DescribeMeterLiveBypassDurationRequest;
+
+DescribeMeterLiveBypassDurationRequest::DescribeMeterLiveBypassDurationRequest()
+    : RpcServiceRequest("live", "2016-11-01", "DescribeMeterLiveBypassDuration") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMeterLiveBypassDurationRequest::~DescribeMeterLiveBypassDurationRequest() {}
+
+std::string DescribeMeterLiveBypassDurationRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeMeterLiveBypassDurationRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeMeterLiveBypassDurationRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeMeterLiveBypassDurationRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeMeterLiveBypassDurationRequest::getAppId() const {
+  return appId_;
+}
+
+void DescribeMeterLiveBypassDurationRequest::setAppId(const std::string &appId) {
+  appId_ = appId;
+  setParameter(std::string("AppId"), appId);
+}
+
+std::string DescribeMeterLiveBypassDurationRequest::getInterval() const {
+  return interval_;
+}
+
+void DescribeMeterLiveBypassDurationRequest::setInterval(const std::string &interval) {
+  interval_ = interval;
+  setParameter(std::string("Interval"), interval);
+}
+

live/src/model/DescribeMeterLiveBypassDurationResult.cc

@@ -0,0 +1,120 @@
+/*
+ * 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/DescribeMeterLiveBypassDurationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeMeterLiveBypassDurationResult::DescribeMeterLiveBypassDurationResult() :
+	ServiceResult()
+{}
+
+DescribeMeterLiveBypassDurationResult::DescribeMeterLiveBypassDurationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMeterLiveBypassDurationResult::~DescribeMeterLiveBypassDurationResult()
+{}
+
+void DescribeMeterLiveBypassDurationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["AudioDuration"].isNull())
+			dataObject.audioDuration = std::stol(valueDataDataItem["AudioDuration"].asString());
+		if(!valueDataDataItem["Single_Audio"].isNull())
+			dataObject.single_Audio = std::stol(valueDataDataItem["Single_Audio"].asString());
+		if(!valueDataDataItem["Single_Video"].isNull())
+			dataObject.single_Video = std::stol(valueDataDataItem["Single_Video"].asString());
+		if(!valueDataDataItem["Timestamp"].isNull())
+			dataObject.timestamp = valueDataDataItem["Timestamp"].asString();
+		if(!valueDataDataItem["TotalDuration"].isNull())
+			dataObject.totalDuration = std::stol(valueDataDataItem["TotalDuration"].asString());
+		if(!valueDataDataItem["V480Duration"].isNull())
+			dataObject.v480Duration = std::stol(valueDataDataItem["V480Duration"].asString());
+		if(!valueDataDataItem["V720Duration"].isNull())
+			dataObject.v720Duration = std::stol(valueDataDataItem["V720Duration"].asString());
+		if(!valueDataDataItem["V1080Duration"].isNull())
+			dataObject.v1080Duration = std::stol(valueDataDataItem["V1080Duration"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["AudioSummaryDuration"].isNull())
+		audioSummaryDuration_ = std::stol(value["AudioSummaryDuration"].asString());
+	if(!value["SingleAudioSummaryDuration"].isNull())
+		singleAudioSummaryDuration_ = std::stol(value["SingleAudioSummaryDuration"].asString());
+	if(!value["SingleVideoSummaryDuration"].isNull())
+		singleVideoSummaryDuration_ = std::stol(value["SingleVideoSummaryDuration"].asString());
+	if(!value["TotalSummaryDuration"].isNull())
+		totalSummaryDuration_ = std::stol(value["TotalSummaryDuration"].asString());
+	if(!value["V480SummaryDuration"].isNull())
+		v480SummaryDuration_ = std::stol(value["V480SummaryDuration"].asString());
+	if(!value["V720SummaryDuration"].isNull())
+		v720SummaryDuration_ = std::stol(value["V720SummaryDuration"].asString());
+	if(!value["V1080SummaryDuration"].isNull())
+		v1080SummaryDuration_ = std::stol(value["V1080SummaryDuration"].asString());
+
+}
+
+long DescribeMeterLiveBypassDurationResult::getV480SummaryDuration()const
+{
+	return v480SummaryDuration_;
+}
+
+long DescribeMeterLiveBypassDurationResult::getV1080SummaryDuration()const
+{
+	return v1080SummaryDuration_;
+}
+
+long DescribeMeterLiveBypassDurationResult::getV720SummaryDuration()const
+{
+	return v720SummaryDuration_;
+}
+
+std::vector<DescribeMeterLiveBypassDurationResult::DataItem> DescribeMeterLiveBypassDurationResult::getData()const
+{
+	return data_;
+}
+
+long DescribeMeterLiveBypassDurationResult::getAudioSummaryDuration()const
+{
+	return audioSummaryDuration_;
+}
+
+long DescribeMeterLiveBypassDurationResult::getTotalSummaryDuration()const
+{
+	return totalSummaryDuration_;
+}
+
+long DescribeMeterLiveBypassDurationResult::getSingleAudioSummaryDuration()const
+{
+	return singleAudioSummaryDuration_;
+}
+
+long DescribeMeterLiveBypassDurationResult::getSingleVideoSummaryDuration()const
+{
+	return singleVideoSummaryDuration_;
+}
+

live/src/model/DescribeMeterLiveInteractionDauResult.cc

@@ -43,10 +43,10 @@ void DescribeMeterLiveInteractionDauResult::parse(const std::string &payload)
 	for (auto valueDataDataItem : allDataNode)
 	{
 		DataItem dataObject;
-		if(!valueDataDataItem["Timestamp"].isNull())
-			dataObject.timestamp = std::stol(valueDataDataItem["Timestamp"].asString());
 		if(!valueDataDataItem["Dau"].isNull())
 			dataObject.dau = valueDataDataItem["Dau"].asString();
+		if(!valueDataDataItem["Timestamp"].isNull())
+			dataObject.timestamp = std::stol(valueDataDataItem["Timestamp"].asString());
 		data_.push_back(dataObject);
 	}
 	if(!value["PeakDau"].isNull())

live/src/model/DescribeMeterLiveRtcDurationResult.cc

@@ -43,12 +43,12 @@ void DescribeMeterLiveRtcDurationResult::parse(const std::string &payload)
 	for (auto valueDataDataItem : allDataNode)
 	{
 		DataItem dataObject;
+		if(!valueDataDataItem["AudioDuration"].isNull())
+			dataObject.audioDuration = std::stol(valueDataDataItem["AudioDuration"].asString());
 		if(!valueDataDataItem["Timestamp"].isNull())
 			dataObject.timestamp = valueDataDataItem["Timestamp"].asString();
 		if(!valueDataDataItem["TotalDuration"].isNull())
 			dataObject.totalDuration = std::stol(valueDataDataItem["TotalDuration"].asString());
-		if(!valueDataDataItem["AudioDuration"].isNull())
-			dataObject.audioDuration = std::stol(valueDataDataItem["AudioDuration"].asString());
 		if(!valueDataDataItem["V480Duration"].isNull())
 			dataObject.v480Duration = std::stol(valueDataDataItem["V480Duration"].asString());
 		if(!valueDataDataItem["V720Duration"].isNull())
@@ -57,10 +57,10 @@ void DescribeMeterLiveRtcDurationResult::parse(const std::string &payload)
 			dataObject.v1080Duration = std::stol(valueDataDataItem["V1080Duration"].asString());
 		data_.push_back(dataObject);
 	}
-	if(!value["TotalSummaryDuration"].isNull())
-		totalSummaryDuration_ = std::stol(value["TotalSummaryDuration"].asString());
 	if(!value["AudioSummaryDuration"].isNull())
 		audioSummaryDuration_ = std::stol(value["AudioSummaryDuration"].asString());
+	if(!value["TotalSummaryDuration"].isNull())
+		totalSummaryDuration_ = std::stol(value["TotalSummaryDuration"].asString());
 	if(!value["V480SummaryDuration"].isNull())
 		v480SummaryDuration_ = std::stol(value["V480SummaryDuration"].asString());
 	if(!value["V720SummaryDuration"].isNull())
@@ -90,13 +90,13 @@ std::vector<DescribeMeterLiveRtcDurationResult::DataItem> DescribeMeterLiveRtcDu
 	return data_;
 }
 
-long DescribeMeterLiveRtcDurationResult::getTotalSummaryDuration()const
+long DescribeMeterLiveRtcDurationResult::getAudioSummaryDuration()const
 {
-	return totalSummaryDuration_;
+	return audioSummaryDuration_;
 }
 
-long DescribeMeterLiveRtcDurationResult::getAudioSummaryDuration()const
+long DescribeMeterLiveRtcDurationResult::getTotalSummaryDuration()const
 {
-	return audioSummaryDuration_;
+	return totalSummaryDuration_;
 }
 

live/src/model/DescribeRTSNativeSDKFirstFrameCostResult.cc

@@ -43,26 +43,26 @@ void DescribeRTSNativeSDKFirstFrameCostResult::parse(const std::string &payload)
 	for (auto valueFirstFrameCostDataData : allFirstFrameCostDataNode)
 	{
 		Data firstFrameCostDataObject;
-		if(!valueFirstFrameCostDataData["TimeStamp"].isNull())
-			firstFrameCostDataObject.timeStamp = valueFirstFrameCostDataData["TimeStamp"].asString();
-		if(!valueFirstFrameCostDataData["Initialized"].isNull())
-			firstFrameCostDataObject.initialized = valueFirstFrameCostDataData["Initialized"].asString();
 		if(!valueFirstFrameCostDataData["Connected"].isNull())
 			firstFrameCostDataObject.connected = valueFirstFrameCostDataData["Connected"].asString();
 		if(!valueFirstFrameCostDataData["FinishGetStreamInfo"].isNull())
 			firstFrameCostDataObject.finishGetStreamInfo = valueFirstFrameCostDataData["FinishGetStreamInfo"].asString();
-		if(!valueFirstFrameCostDataData["FirstPacket"].isNull())
-			firstFrameCostDataObject.firstPacket = valueFirstFrameCostDataData["FirstPacket"].asString();
 		if(!valueFirstFrameCostDataData["FirstFrameComplete"].isNull())
 			firstFrameCostDataObject.firstFrameComplete = valueFirstFrameCostDataData["FirstFrameComplete"].asString();
+		if(!valueFirstFrameCostDataData["FirstPacket"].isNull())
+			firstFrameCostDataObject.firstPacket = valueFirstFrameCostDataData["FirstPacket"].asString();
+		if(!valueFirstFrameCostDataData["Initialized"].isNull())
+			firstFrameCostDataObject.initialized = valueFirstFrameCostDataData["Initialized"].asString();
+		if(!valueFirstFrameCostDataData["TimeStamp"].isNull())
+			firstFrameCostDataObject.timeStamp = valueFirstFrameCostDataData["TimeStamp"].asString();
 		firstFrameCostData_.push_back(firstFrameCostDataObject);
 	}
 	if(!value["DataInterval"].isNull())
 		dataInterval_ = value["DataInterval"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 

live/src/model/DescribeRTSNativeSDKFirstFrameDelayResult.cc

@@ -43,18 +43,18 @@ void DescribeRTSNativeSDKFirstFrameDelayResult::parse(const std::string &payload
 	for (auto valueFrameDelayDataData : allFrameDelayDataNode)
 	{
 		Data frameDelayDataObject;
-		if(!valueFrameDelayDataData["TimeStamp"].isNull())
-			frameDelayDataObject.timeStamp = valueFrameDelayDataData["TimeStamp"].asString();
 		if(!valueFrameDelayDataData["FrameDelay"].isNull())
 			frameDelayDataObject.frameDelay = valueFrameDelayDataData["FrameDelay"].asString();
+		if(!valueFrameDelayDataData["TimeStamp"].isNull())
+			frameDelayDataObject.timeStamp = valueFrameDelayDataData["TimeStamp"].asString();
 		frameDelayData_.push_back(frameDelayDataObject);
 	}
 	if(!value["DataInterval"].isNull())
 		dataInterval_ = value["DataInterval"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 

live/src/model/DescribeRTSNativeSDKPlayFailStatusResult.cc

@@ -61,10 +61,10 @@ void DescribeRTSNativeSDKPlayFailStatusResult::parse(const std::string &payload)
 	}
 	if(!value["DataInterval"].isNull())
 		dataInterval_ = value["DataInterval"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 

live/src/model/DescribeRTSNativeSDKPlayTimeResult.cc

@@ -43,20 +43,20 @@ void DescribeRTSNativeSDKPlayTimeResult::parse(const std::string &payload)
 	for (auto valuePlayTimeDataData : allPlayTimeDataNode)
 	{
 		Data playTimeDataObject;
-		if(!valuePlayTimeDataData["TimeStamp"].isNull())
-			playTimeDataObject.timeStamp = valuePlayTimeDataData["TimeStamp"].asString();
 		if(!valuePlayTimeDataData["PlayTime"].isNull())
 			playTimeDataObject.playTime = valuePlayTimeDataData["PlayTime"].asString();
 		if(!valuePlayTimeDataData["StallTime"].isNull())
 			playTimeDataObject.stallTime = valuePlayTimeDataData["StallTime"].asString();
+		if(!valuePlayTimeDataData["TimeStamp"].isNull())
+			playTimeDataObject.timeStamp = valuePlayTimeDataData["TimeStamp"].asString();
 		playTimeData_.push_back(playTimeDataObject);
 	}
 	if(!value["DataInterval"].isNull())
 		dataInterval_ = value["DataInterval"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 

live/src/model/DescribeRTSNativeSDKVvDataResult.cc

@@ -45,18 +45,18 @@ void DescribeRTSNativeSDKVvDataResult::parse(const std::string &payload)
 		Data vvDataObject;
 		if(!valueVvDataData["TimeStamp"].isNull())
 			vvDataObject.timeStamp = valueVvDataData["TimeStamp"].asString();
-		if(!valueVvDataData["VvTotal"].isNull())
-			vvDataObject.vvTotal = valueVvDataData["VvTotal"].asString();
 		if(!valueVvDataData["VvSuccess"].isNull())
 			vvDataObject.vvSuccess = valueVvDataData["VvSuccess"].asString();
+		if(!valueVvDataData["VvTotal"].isNull())
+			vvDataObject.vvTotal = valueVvDataData["VvTotal"].asString();
 		vvData_.push_back(vvDataObject);
 	}
 	if(!value["DataInterval"].isNull())
 		dataInterval_ = value["DataInterval"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
 
 }
 

live/src/model/DescribeShowListResult.cc

@@ -40,37 +40,37 @@ void DescribeShowListResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto showListInfoNode = value["ShowListInfo"];
-	if(!showListInfoNode["HighPriorityShowStartTime"].isNull())
-		showListInfo_.highPriorityShowStartTime = showListInfoNode["HighPriorityShowStartTime"].asString();
-	if(!showListInfoNode["TotalShowListRepeatTimes"].isNull())
-		showListInfo_.totalShowListRepeatTimes = std::stoi(showListInfoNode["TotalShowListRepeatTimes"].asString());
-	if(!showListInfoNode["ShowListRepeatTimes"].isNull())
-		showListInfo_.showListRepeatTimes = std::stoi(showListInfoNode["ShowListRepeatTimes"].asString());
 	if(!showListInfoNode["CurrentShowId"].isNull())
 		showListInfo_.currentShowId = showListInfoNode["CurrentShowId"].asString();
 	if(!showListInfoNode["HighPriorityShowId"].isNull())
 		showListInfo_.highPriorityShowId = showListInfoNode["HighPriorityShowId"].asString();
+	if(!showListInfoNode["HighPriorityShowStartTime"].isNull())
+		showListInfo_.highPriorityShowStartTime = showListInfoNode["HighPriorityShowStartTime"].asString();
+	if(!showListInfoNode["ShowListRepeatTimes"].isNull())
+		showListInfo_.showListRepeatTimes = std::stoi(showListInfoNode["ShowListRepeatTimes"].asString());
+	if(!showListInfoNode["TotalShowListRepeatTimes"].isNull())
+		showListInfo_.totalShowListRepeatTimes = std::stoi(showListInfoNode["TotalShowListRepeatTimes"].asString());
 	auto allShowListNode = showListInfoNode["ShowList"]["Show"];
 	for (auto showListInfoNodeShowListShow : allShowListNode)
 	{
 		ShowListInfo::Show showObject;
-		if(!showListInfoNodeShowListShow["ShowName"].isNull())
-			showObject.showName = showListInfoNodeShowListShow["ShowName"].asString();
 		if(!showListInfoNodeShowListShow["Duration"].isNull())
 			showObject.duration = std::stol(showListInfoNodeShowListShow["Duration"].asString());
 		if(!showListInfoNodeShowListShow["RepeatTimes"].isNull())
 			showObject.repeatTimes = std::stoi(showListInfoNodeShowListShow["RepeatTimes"].asString());
 		if(!showListInfoNodeShowListShow["ShowId"].isNull())
 			showObject.showId = showListInfoNodeShowListShow["ShowId"].asString();
+		if(!showListInfoNodeShowListShow["ShowName"].isNull())
+			showObject.showName = showListInfoNodeShowListShow["ShowName"].asString();
 		auto resourceInfoNode = value["ResourceInfo"];
 		if(!resourceInfoNode["LiveInputType"].isNull())
 			showObject.resourceInfo.liveInputType = std::stoi(resourceInfoNode["LiveInputType"].asString());
-		if(!resourceInfoNode["ResourceUrl"].isNull())
-			showObject.resourceInfo.resourceUrl = resourceInfoNode["ResourceUrl"].asString();
-		if(!resourceInfoNode["ResourceType"].isNull())
-			showObject.resourceInfo.resourceType = resourceInfoNode["ResourceType"].asString();
 		if(!resourceInfoNode["ResourceId"].isNull())
 			showObject.resourceInfo.resourceId = resourceInfoNode["ResourceId"].asString();
+		if(!resourceInfoNode["ResourceType"].isNull())
+			showObject.resourceInfo.resourceType = resourceInfoNode["ResourceType"].asString();
+		if(!resourceInfoNode["ResourceUrl"].isNull())
+			showObject.resourceInfo.resourceUrl = resourceInfoNode["ResourceUrl"].asString();
 		showListInfo_.showList.push_back(showObject);
 	}
 	if(!value["ShowList"].isNull())

live/src/model/GetEdgeTranscodeJobResult.cc

@@ -40,28 +40,28 @@ void GetEdgeTranscodeJobResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto jobNode = value["Job"];
-	if(!jobNode["Status"].isNull())
-		job_.status = jobNode["Status"].asString();
-	if(!jobNode["Type"].isNull())
-		job_.type = jobNode["Type"].asString();
-	if(!jobNode["StreamInput"].isNull())
-		job_.streamInput = jobNode["StreamInput"].asString();
-	if(!jobNode["StreamOutput"].isNull())
-		job_.streamOutput = jobNode["StreamOutput"].asString();
-	if(!jobNode["LastStopAt"].isNull())
-		job_.lastStopAt = jobNode["LastStopAt"].asString();
-	if(!jobNode["LastStartAt"].isNull())
-		job_.lastStartAt = jobNode["LastStartAt"].asString();
 	if(!jobNode["CreateTime"].isNull())
 		job_.createTime = jobNode["CreateTime"].asString();
 	if(!jobNode["JobId"].isNull())
 		job_.jobId = jobNode["JobId"].asString();
-	if(!jobNode["TemplateName"].isNull())
-		job_.templateName = jobNode["TemplateName"].asString();
+	if(!jobNode["LastStartAt"].isNull())
+		job_.lastStartAt = jobNode["LastStartAt"].asString();
+	if(!jobNode["LastStopAt"].isNull())
+		job_.lastStopAt = jobNode["LastStopAt"].asString();
 	if(!jobNode["Name"].isNull())
 		job_.name = jobNode["Name"].asString();
+	if(!jobNode["Status"].isNull())
+		job_.status = jobNode["Status"].asString();
+	if(!jobNode["StreamInput"].isNull())
+		job_.streamInput = jobNode["StreamInput"].asString();
+	if(!jobNode["StreamOutput"].isNull())
+		job_.streamOutput = jobNode["StreamOutput"].asString();
 	if(!jobNode["TemplateId"].isNull())
 		job_.templateId = jobNode["TemplateId"].asString();
+	if(!jobNode["TemplateName"].isNull())
+		job_.templateName = jobNode["TemplateName"].asString();
+	if(!jobNode["Type"].isNull())
+		job_.type = jobNode["Type"].asString();
 
 }
 

live/src/model/GetEdgeTranscodeTemplateResult.cc

@@ -40,24 +40,24 @@ void GetEdgeTranscodeTemplateResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto _templateNode = value["Template"];
-	if(!_templateNode["Type"].isNull())
-		_template_.type = _templateNode["Type"].asString();
-	if(!_templateNode["Gop"].isNull())
-		_template_.gop = _templateNode["Gop"].asString();
-	if(!_templateNode["CreateTime"].isNull())
-		_template_.createTime = _templateNode["CreateTime"].asString();
+	if(!_templateNode["Bitrate"].isNull())
+		_template_.bitrate = _templateNode["Bitrate"].asString();
 	if(!_templateNode["Codec"].isNull())
 		_template_.codec = _templateNode["Codec"].asString();
+	if(!_templateNode["CreateTime"].isNull())
+		_template_.createTime = _templateNode["CreateTime"].asString();
 	if(!_templateNode["Fps"].isNull())
 		_template_.fps = _templateNode["Fps"].asString();
-	if(!_templateNode["Bitrate"].isNull())
-		_template_.bitrate = _templateNode["Bitrate"].asString();
+	if(!_templateNode["Gop"].isNull())
+		_template_.gop = _templateNode["Gop"].asString();
 	if(!_templateNode["Name"].isNull())
 		_template_.name = _templateNode["Name"].asString();
 	if(!_templateNode["Resolution"].isNull())
 		_template_.resolution = _templateNode["Resolution"].asString();
 	if(!_templateNode["TemplateId"].isNull())
 		_template_.templateId = _templateNode["TemplateId"].asString();
+	if(!_templateNode["Type"].isNull())
+		_template_.type = _templateNode["Type"].asString();
 
 }
 

live/src/model/GetMessageAppResult.cc

@@ -40,18 +40,18 @@ void GetMessageAppResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
+	if(!resultNode["AppConfig"].isNull())
+		result_.appConfig = resultNode["AppConfig"].asString();
 	if(!resultNode["AppId"].isNull())
 		result_.appId = resultNode["AppId"].asString();
 	if(!resultNode["AppName"].isNull())
 		result_.appName = resultNode["AppName"].asString();
 	if(!resultNode["CreateTime"].isNull())
 		result_.createTime = std::stol(resultNode["CreateTime"].asString());
-	if(!resultNode["Status"].isNull())
-		result_.status = std::stoi(resultNode["Status"].asString());
-	if(!resultNode["AppConfig"].isNull())
-		result_.appConfig = resultNode["AppConfig"].asString();
 	if(!resultNode["Extension"].isNull())
 		result_.extension = resultNode["Extension"].asString();
+	if(!resultNode["Status"].isNull())
+		result_.status = std::stoi(resultNode["Status"].asString());
 
 }
 

live/src/model/GetMessageGroupResult.cc

@@ -40,18 +40,18 @@ void GetMessageGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["GroupId"].isNull())
-		result_.groupId = resultNode["GroupId"].asString();
 	if(!resultNode["CreateTime"].isNull())
 		result_.createTime = std::stol(resultNode["CreateTime"].asString());
-	if(!resultNode["Status"].isNull())
-		result_.status = std::stoi(resultNode["Status"].asString());
 	if(!resultNode["CreatorId"].isNull())
 		result_.creatorId = resultNode["CreatorId"].asString();
 	if(!resultNode["Extension"].isNull())
 		result_.extension = resultNode["Extension"].asString();
+	if(!resultNode["GroupId"].isNull())
+		result_.groupId = resultNode["GroupId"].asString();
 	if(!resultNode["IsMuteAll"].isNull())
 		result_.isMuteAll = resultNode["IsMuteAll"].asString() == "true";
+	if(!resultNode["Status"].isNull())
+		result_.status = std::stoi(resultNode["Status"].asString());
 
 }
 

live/src/model/GetMessageTokenResult.cc

@@ -42,10 +42,10 @@ void GetMessageTokenResult::parse(const std::string &payload)
 	auto resultNode = value["Result"];
 	if(!resultNode["AccessToken"].isNull())
 		result_.accessToken = resultNode["AccessToken"].asString();
-	if(!resultNode["RefreshToken"].isNull())
-		result_.refreshToken = resultNode["RefreshToken"].asString();
 	if(!resultNode["AccessTokenExpiredTime"].isNull())
 		result_.accessTokenExpiredTime = std::stol(resultNode["AccessTokenExpiredTime"].asString());
+	if(!resultNode["RefreshToken"].isNull())
+		result_.refreshToken = resultNode["RefreshToken"].asString();
 
 }
 

live/src/model/ListEdgeTranscodeJobResult.cc

@@ -43,28 +43,28 @@ void ListEdgeTranscodeJobResult::parse(const std::string &payload)
 	for (auto valueJobListJob : allJobListNode)
 	{
 		Job jobListObject;
-		if(!valueJobListJob["Status"].isNull())
-			jobListObject.status = valueJobListJob["Status"].asString();
-		if(!valueJobListJob["Type"].isNull())
-			jobListObject.type = valueJobListJob["Type"].asString();
-		if(!valueJobListJob["StreamInput"].isNull())
-			jobListObject.streamInput = valueJobListJob["StreamInput"].asString();
-		if(!valueJobListJob["StreamOutput"].isNull())
-			jobListObject.streamOutput = valueJobListJob["StreamOutput"].asString();
-		if(!valueJobListJob["LastStopAt"].isNull())
-			jobListObject.lastStopAt = valueJobListJob["LastStopAt"].asString();
-		if(!valueJobListJob["LastStartAt"].isNull())
-			jobListObject.lastStartAt = valueJobListJob["LastStartAt"].asString();
 		if(!valueJobListJob["CreateTime"].isNull())
 			jobListObject.createTime = valueJobListJob["CreateTime"].asString();
 		if(!valueJobListJob["JobId"].isNull())
 			jobListObject.jobId = valueJobListJob["JobId"].asString();
-		if(!valueJobListJob["TemplateName"].isNull())
-			jobListObject.templateName = valueJobListJob["TemplateName"].asString();
+		if(!valueJobListJob["LastStartAt"].isNull())
+			jobListObject.lastStartAt = valueJobListJob["LastStartAt"].asString();
+		if(!valueJobListJob["LastStopAt"].isNull())
+			jobListObject.lastStopAt = valueJobListJob["LastStopAt"].asString();
 		if(!valueJobListJob["Name"].isNull())
 			jobListObject.name = valueJobListJob["Name"].asString();
+		if(!valueJobListJob["Status"].isNull())
+			jobListObject.status = valueJobListJob["Status"].asString();
+		if(!valueJobListJob["StreamInput"].isNull())
+			jobListObject.streamInput = valueJobListJob["StreamInput"].asString();
+		if(!valueJobListJob["StreamOutput"].isNull())
+			jobListObject.streamOutput = valueJobListJob["StreamOutput"].asString();
 		if(!valueJobListJob["TemplateId"].isNull())
 			jobListObject.templateId = valueJobListJob["TemplateId"].asString();
+		if(!valueJobListJob["TemplateName"].isNull())
+			jobListObject.templateName = valueJobListJob["TemplateName"].asString();
+		if(!valueJobListJob["Type"].isNull())
+			jobListObject.type = valueJobListJob["Type"].asString();
 		jobList_.push_back(jobListObject);
 	}
 	if(!value["TotalCount"].isNull())

live/src/model/ListEdgeTranscodeTemplateResult.cc

@@ -43,24 +43,24 @@ void ListEdgeTranscodeTemplateResult::parse(const std::string &payload)
 	for (auto valueTemplateListTemplate : allTemplateListNode)
 	{
 		_Template templateListObject;
-		if(!valueTemplateListTemplate["Type"].isNull())
-			templateListObject.type = valueTemplateListTemplate["Type"].asString();
-		if(!valueTemplateListTemplate["Gop"].isNull())
-			templateListObject.gop = valueTemplateListTemplate["Gop"].asString();
-		if(!valueTemplateListTemplate["CreateTime"].isNull())
-			templateListObject.createTime = valueTemplateListTemplate["CreateTime"].asString();
+		if(!valueTemplateListTemplate["Bitrate"].isNull())
+			templateListObject.bitrate = valueTemplateListTemplate["Bitrate"].asString();
 		if(!valueTemplateListTemplate["Codec"].isNull())
 			templateListObject.codec = valueTemplateListTemplate["Codec"].asString();
+		if(!valueTemplateListTemplate["CreateTime"].isNull())
+			templateListObject.createTime = valueTemplateListTemplate["CreateTime"].asString();
 		if(!valueTemplateListTemplate["Fps"].isNull())
 			templateListObject.fps = valueTemplateListTemplate["Fps"].asString();
-		if(!valueTemplateListTemplate["Bitrate"].isNull())
-			templateListObject.bitrate = valueTemplateListTemplate["Bitrate"].asString();
+		if(!valueTemplateListTemplate["Gop"].isNull())
+			templateListObject.gop = valueTemplateListTemplate["Gop"].asString();
 		if(!valueTemplateListTemplate["Name"].isNull())
 			templateListObject.name = valueTemplateListTemplate["Name"].asString();
 		if(!valueTemplateListTemplate["Resolution"].isNull())
 			templateListObject.resolution = valueTemplateListTemplate["Resolution"].asString();
 		if(!valueTemplateListTemplate["TemplateId"].isNull())
 			templateListObject.templateId = valueTemplateListTemplate["TemplateId"].asString();
+		if(!valueTemplateListTemplate["Type"].isNull())
+			templateListObject.type = valueTemplateListTemplate["Type"].asString();
 		templateList_.push_back(templateListObject);
 	}
 	if(!value["TotalCount"].isNull())

live/src/model/ListLiveMessageAppsResult.cc

@@ -47,18 +47,18 @@ void ListLiveMessageAppsResult::parse(const std::string &payload)
 			appListObject.appId = valueAppListApps["AppId"].asString();
 		if(!valueAppListApps["AppKey"].isNull())
 			appListObject.appKey = valueAppListApps["AppKey"].asString();
-		if(!valueAppListApps["AppSign"].isNull())
-			appListObject.appSign = valueAppListApps["AppSign"].asString();
-		if(!valueAppListApps["Disable"].isNull())
-			appListObject.disable = valueAppListApps["Disable"].asString();
 		if(!valueAppListApps["AppName"].isNull())
 			appListObject.appName = valueAppListApps["AppName"].asString();
+		if(!valueAppListApps["AppSign"].isNull())
+			appListObject.appSign = valueAppListApps["AppSign"].asString();
 		if(!valueAppListApps["CreateTime"].isNull())
 			appListObject.createTime = std::stol(valueAppListApps["CreateTime"].asString());
-		if(!valueAppListApps["ModifyTime"].isNull())
-			appListObject.modifyTime = std::stol(valueAppListApps["ModifyTime"].asString());
 		if(!valueAppListApps["DataCenter"].isNull())
 			appListObject.dataCenter = valueAppListApps["DataCenter"].asString();
+		if(!valueAppListApps["Disable"].isNull())
+			appListObject.disable = valueAppListApps["Disable"].asString();
+		if(!valueAppListApps["ModifyTime"].isNull())
+			appListObject.modifyTime = std::stol(valueAppListApps["ModifyTime"].asString());
 		appList_.push_back(appListObject);
 	}
 	if(!value["HasMore"].isNull())

live/src/model/ListLiveMessageGroupsRequest.cc

@@ -34,6 +34,15 @@ void ListLiveMessageGroupsRequest::setSortType(int sortType) {
   setParameter(std::string("SortType"), std::to_string(sortType));
 }
 
+int ListLiveMessageGroupsRequest::getGroupStatus() const {
+  return groupStatus_;
+}
+
+void ListLiveMessageGroupsRequest::setGroupStatus(int groupStatus) {
+  groupStatus_ = groupStatus;
+  setParameter(std::string("GroupStatus"), std::to_string(groupStatus));
+}
+
 long ListLiveMessageGroupsRequest::getNextPageToken() const {
   return nextPageToken_;
 }

live/src/model/ListMessageAppResult.cc

@@ -40,26 +40,26 @@ void ListMessageAppResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["Total"].isNull())
-		result_.total = std::stoi(resultNode["Total"].asString());
 	if(!resultNode["HasMore"].isNull())
 		result_.hasMore = resultNode["HasMore"].asString() == "true";
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
 	auto allAppListNode = resultNode["AppList"]["appListItem"];
 	for (auto resultNodeAppListappListItem : allAppListNode)
 	{
 		Result::AppListItem appListItemObject;
+		if(!resultNodeAppListappListItem["AppConfig"].isNull())
+			appListItemObject.appConfig = resultNodeAppListappListItem["AppConfig"].asString();
 		if(!resultNodeAppListappListItem["AppId"].isNull())
 			appListItemObject.appId = resultNodeAppListappListItem["AppId"].asString();
 		if(!resultNodeAppListappListItem["AppName"].isNull())
 			appListItemObject.appName = resultNodeAppListappListItem["AppName"].asString();
 		if(!resultNodeAppListappListItem["CreateTime"].isNull())
 			appListItemObject.createTime = std::stol(resultNodeAppListappListItem["CreateTime"].asString());
-		if(!resultNodeAppListappListItem["Status"].isNull())
-			appListItemObject.status = std::stoi(resultNodeAppListappListItem["Status"].asString());
-		if(!resultNodeAppListappListItem["AppConfig"].isNull())
-			appListItemObject.appConfig = resultNodeAppListappListItem["AppConfig"].asString();
 		if(!resultNodeAppListappListItem["Extension"].isNull())
 			appListItemObject.extension = resultNodeAppListappListItem["Extension"].asString();
+		if(!resultNodeAppListappListItem["Status"].isNull())
+			appListItemObject.status = std::stoi(resultNodeAppListappListItem["Status"].asString());
 		result_.appList.push_back(appListItemObject);
 	}
 

live/src/model/ListMessageGroupResult.cc

@@ -40,26 +40,26 @@ void ListMessageGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["Total"].isNull())
-		result_.total = std::stoi(resultNode["Total"].asString());
 	if(!resultNode["HasMore"].isNull())
 		result_.hasMore = resultNode["HasMore"].asString() == "true";
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
 	auto allGroupListNode = resultNode["GroupList"]["groupListItem"];
 	for (auto resultNodeGroupListgroupListItem : allGroupListNode)
 	{
 		Result::GroupListItem groupListItemObject;
-		if(!resultNodeGroupListgroupListItem["GroupId"].isNull())
-			groupListItemObject.groupId = resultNodeGroupListgroupListItem["GroupId"].asString();
 		if(!resultNodeGroupListgroupListItem["AppId"].isNull())
 			groupListItemObject.appId = resultNodeGroupListgroupListItem["AppId"].asString();
 		if(!resultNodeGroupListgroupListItem["CreateTime"].isNull())
 			groupListItemObject.createTime = std::stol(resultNodeGroupListgroupListItem["CreateTime"].asString());
-		if(!resultNodeGroupListgroupListItem["Status"].isNull())
-			groupListItemObject.status = std::stoi(resultNodeGroupListgroupListItem["Status"].asString());
 		if(!resultNodeGroupListgroupListItem["CreatorId"].isNull())
 			groupListItemObject.creatorId = resultNodeGroupListgroupListItem["CreatorId"].asString();
 		if(!resultNodeGroupListgroupListItem["Extension"].isNull())
 			groupListItemObject.extension = resultNodeGroupListgroupListItem["Extension"].asString();
+		if(!resultNodeGroupListgroupListItem["GroupId"].isNull())
+			groupListItemObject.groupId = resultNodeGroupListgroupListItem["GroupId"].asString();
+		if(!resultNodeGroupListgroupListItem["Status"].isNull())
+			groupListItemObject.status = std::stoi(resultNodeGroupListgroupListItem["Status"].asString());
 		result_.groupList.push_back(groupListItemObject);
 	}
 

live/src/model/ListMessageGroupUserByIdResult.cc

@@ -40,24 +40,24 @@ void ListMessageGroupUserByIdResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["Total"].isNull())
-		result_.total = std::stoi(resultNode["Total"].asString());
 	if(!resultNode["HasMore"].isNull())
 		result_.hasMore = resultNode["HasMore"].asString() == "true";
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
 	auto allUserListNode = resultNode["UserList"]["userListItem"];
 	for (auto resultNodeUserListuserListItem : allUserListNode)
 	{
 		Result::UserListItem userListItemObject;
-		if(!resultNodeUserListuserListItem["UserId"].isNull())
-			userListItemObject.userId = resultNodeUserListuserListItem["UserId"].asString();
-		if(!resultNodeUserListuserListItem["UserNick"].isNull())
-			userListItemObject.userNick = resultNodeUserListuserListItem["UserNick"].asString();
+		if(!resultNodeUserListuserListItem["IsMute"].isNull())
+			userListItemObject.isMute = resultNodeUserListuserListItem["IsMute"].asString() == "true";
 		if(!resultNodeUserListuserListItem["UserAvatar"].isNull())
 			userListItemObject.userAvatar = resultNodeUserListuserListItem["UserAvatar"].asString();
 		if(!resultNodeUserListuserListItem["UserExtension"].isNull())
 			userListItemObject.userExtension = resultNodeUserListuserListItem["UserExtension"].asString();
-		if(!resultNodeUserListuserListItem["IsMute"].isNull())
-			userListItemObject.isMute = resultNodeUserListuserListItem["IsMute"].asString() == "true";
+		if(!resultNodeUserListuserListItem["UserId"].isNull())
+			userListItemObject.userId = resultNodeUserListuserListItem["UserId"].asString();
+		if(!resultNodeUserListuserListItem["UserNick"].isNull())
+			userListItemObject.userNick = resultNodeUserListuserListItem["UserNick"].asString();
 		auto allMuteBy = value["MuteBy"]["muteBy"];
 		for (auto value : allMuteBy)
 			userListItemObject.muteBy.push_back(value.asString());

live/src/model/ListMessageGroupUserResult.cc

@@ -40,18 +40,18 @@ void ListMessageGroupUserResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["Total"].isNull())
-		result_.total = std::stoi(resultNode["Total"].asString());
 	if(!resultNode["HasMore"].isNull())
 		result_.hasMore = resultNode["HasMore"].asString() == "true";
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
 	auto allUserListNode = resultNode["UserList"]["userListItem"];
 	for (auto resultNodeUserListuserListItem : allUserListNode)
 	{
 		Result::UserListItem userListItemObject;
-		if(!resultNodeUserListuserListItem["UserId"].isNull())
-			userListItemObject.userId = resultNodeUserListuserListItem["UserId"].asString();
 		if(!resultNodeUserListuserListItem["JoinTime"].isNull())
 			userListItemObject.joinTime = std::stol(resultNodeUserListuserListItem["JoinTime"].asString());
+		if(!resultNodeUserListuserListItem["UserId"].isNull())
+			userListItemObject.userId = resultNodeUserListuserListItem["UserId"].asString();
 		result_.userList.push_back(userListItemObject);
 	}
 

live/src/model/ListMessageResult.cc

@@ -46,16 +46,16 @@ void ListMessageResult::parse(const std::string &payload)
 	for (auto resultNodeMessageListmessageListItem : allMessageListNode)
 	{
 		Result::MessageListItem messageListItemObject;
+		if(!resultNodeMessageListmessageListItem["Data"].isNull())
+			messageListItemObject.data = resultNodeMessageListmessageListItem["Data"].asString();
 		if(!resultNodeMessageListmessageListItem["GroupId"].isNull())
 			messageListItemObject.groupId = resultNodeMessageListmessageListItem["GroupId"].asString();
 		if(!resultNodeMessageListmessageListItem["MessageId"].isNull())
 			messageListItemObject.messageId = resultNodeMessageListmessageListItem["MessageId"].asString();
-		if(!resultNodeMessageListmessageListItem["Type"].isNull())
-			messageListItemObject.type = std::stoi(resultNodeMessageListmessageListItem["Type"].asString());
 		if(!resultNodeMessageListmessageListItem["SenderId"].isNull())
 			messageListItemObject.senderId = resultNodeMessageListmessageListItem["SenderId"].asString();
-		if(!resultNodeMessageListmessageListItem["Data"].isNull())
-			messageListItemObject.data = resultNodeMessageListmessageListItem["Data"].asString();
+		if(!resultNodeMessageListmessageListItem["Type"].isNull())
+			messageListItemObject.type = std::stoi(resultNodeMessageListmessageListItem["Type"].asString());
 		result_.messageList.push_back(messageListItemObject);
 	}
 

live/src/model/ListMuteGroupUserResult.cc

@@ -40,10 +40,10 @@ void ListMuteGroupUserResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resultNode = value["Result"];
-	if(!resultNode["Total"].isNull())
-		result_.total = std::stoi(resultNode["Total"].asString());
 	if(!resultNode["HasMore"].isNull())
 		result_.hasMore = resultNode["HasMore"].asString() == "true";
+	if(!resultNode["Total"].isNull())
+		result_.total = std::stoi(resultNode["Total"].asString());
 	auto allUserListNode = resultNode["UserList"]["userListItem"];
 	for (auto resultNodeUserListuserListItem : allUserListNode)
 	{

live/src/model/ModifyLiveMessageUserInfoResult.cc

@@ -39,30 +39,30 @@ void ModifyLiveMessageUserInfoResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allSuccessListNode = value["SuccessList"]["SuccessGroups"];
-	for (auto valueSuccessListSuccessGroups : allSuccessListNode)
-	{
-		SuccessGroups successListObject;
-		if(!valueSuccessListSuccessGroups["GroupId"].isNull())
-			successListObject.groupId = valueSuccessListSuccessGroups["GroupId"].asString();
-		if(!valueSuccessListSuccessGroups["Success"].isNull())
-			successListObject.success = valueSuccessListSuccessGroups["Success"].asString() == "true";
-		successList_.push_back(successListObject);
-	}
 	auto allFailListNode = value["FailList"]["FailGroups"];
 	for (auto valueFailListFailGroups : allFailListNode)
 	{
 		FailGroups failListObject;
+		if(!valueFailListFailGroups["Code"].isNull())
+			failListObject.code = std::stoi(valueFailListFailGroups["Code"].asString());
 		if(!valueFailListFailGroups["GroupId"].isNull())
 			failListObject.groupId = valueFailListFailGroups["GroupId"].asString();
-		if(!valueFailListFailGroups["Success"].isNull())
-			failListObject.success = valueFailListFailGroups["Success"].asString() == "true";
 		if(!valueFailListFailGroups["Reason"].isNull())
 			failListObject.reason = valueFailListFailGroups["Reason"].asString();
-		if(!valueFailListFailGroups["Code"].isNull())
-			failListObject.code = std::stoi(valueFailListFailGroups["Code"].asString());
+		if(!valueFailListFailGroups["Success"].isNull())
+			failListObject.success = valueFailListFailGroups["Success"].asString() == "true";
 		failList_.push_back(failListObject);
 	}
+	auto allSuccessListNode = value["SuccessList"]["SuccessGroups"];
+	for (auto valueSuccessListSuccessGroups : allSuccessListNode)
+	{
+		SuccessGroups successListObject;
+		if(!valueSuccessListSuccessGroups["GroupId"].isNull())
+			successListObject.groupId = valueSuccessListSuccessGroups["GroupId"].asString();
+		if(!valueSuccessListSuccessGroups["Success"].isNull())
+			successListObject.success = valueSuccessListSuccessGroups["Success"].asString() == "true";
+		successList_.push_back(successListObject);
+	}
 
 }
 

live/src/model/QueryMessageAppResult.cc

@@ -43,26 +43,26 @@ void QueryMessageAppResult::parse(const std::string &payload)
 	for (auto valueResultresultItem : allResultNode)
 	{
 		ResultItem resultObject;
-		if(!valueResultresultItem["TotalCount"].isNull())
-			resultObject.totalCount = std::stoi(valueResultresultItem["TotalCount"].asString());
 		if(!valueResultresultItem["HasMore"].isNull())
 			resultObject.hasMore = valueResultresultItem["HasMore"].asString() == "true";
+		if(!valueResultresultItem["TotalCount"].isNull())
+			resultObject.totalCount = std::stoi(valueResultresultItem["TotalCount"].asString());
 		auto allAppListNode = valueResultresultItem["AppList"]["appListItem"];
 		for (auto valueResultresultItemAppListappListItem : allAppListNode)
 		{
 			ResultItem::AppListItem appListObject;
+			if(!valueResultresultItemAppListappListItem["AppConfig"].isNull())
+				appListObject.appConfig = valueResultresultItemAppListappListItem["AppConfig"].asString();
 			if(!valueResultresultItemAppListappListItem["AppId"].isNull())
 				appListObject.appId = valueResultresultItemAppListappListItem["AppId"].asString();
 			if(!valueResultresultItemAppListappListItem["AppName"].isNull())
 				appListObject.appName = valueResultresultItemAppListappListItem["AppName"].asString();
 			if(!valueResultresultItemAppListappListItem["CreateTime"].isNull())
 				appListObject.createTime = std::stol(valueResultresultItemAppListappListItem["CreateTime"].asString());
-			if(!valueResultresultItemAppListappListItem["Status"].isNull())
-				appListObject.status = std::stoi(valueResultresultItemAppListappListItem["Status"].asString());
-			if(!valueResultresultItemAppListappListItem["AppConfig"].isNull())
-				appListObject.appConfig = valueResultresultItemAppListappListItem["AppConfig"].asString();
 			if(!valueResultresultItemAppListappListItem["Extension"].isNull())
 				appListObject.extension = valueResultresultItemAppListappListItem["Extension"].asString();
+			if(!valueResultresultItemAppListappListItem["Status"].isNull())
+				appListObject.status = std::stoi(valueResultresultItemAppListappListItem["Status"].asString());
 			resultObject.appList.push_back(appListObject);
 		}
 		result_.push_back(resultObject);

live/src/model/StartLiveMPUTaskRequest.cc

@@ -60,20 +60,20 @@ void StartLiveMPUTaskRequest::setTranscodeParams(const StartLiveMPUTaskRequest::
   for(int dep1 = 0; dep1 != transcodeParams.layout.userPanes.size(); dep1++) {
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".BackgroundImageUrl", transcodeParams.layout.userPanes[dep1].backgroundImageUrl);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".ZOrder", transcodeParams.layout.userPanes[dep1].zOrder);
-    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".X", transcodeParams.layout.userPanes[dep1].x);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".Width", transcodeParams.layout.userPanes[dep1].width);
+    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".X", transcodeParams.layout.userPanes[dep1].x);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".Y", transcodeParams.layout.userPanes[dep1].y);
+    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".RenderMode", transcodeParams.layout.userPanes[dep1].renderMode);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".UserInfo.SourceType", transcodeParams.layout.userPanes[dep1].userInfo.sourceType);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".UserInfo.UserId", transcodeParams.layout.userPanes[dep1].userInfo.userId);
-    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".RenderMode", transcodeParams.layout.userPanes[dep1].renderMode);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".Height", transcodeParams.layout.userPanes[dep1].height);
   }
   setParameter(std::string("TranscodeParams") + ".Layout.LayoutMode", transcodeParams.layout.layoutMode);
   setParameter(std::string("TranscodeParams") + ".Layout.MaxVideoUser.StreamType", transcodeParams.layout.maxVideoUser.streamType);
   setParameter(std::string("TranscodeParams") + ".Layout.MaxVideoUser.SourceType", transcodeParams.layout.maxVideoUser.sourceType);
   setParameter(std::string("TranscodeParams") + ".Layout.MaxVideoUser.UserId", transcodeParams.layout.maxVideoUser.userId);
-  setParameter(std::string("TranscodeParams") + ".Background.URL", transcodeParams.background.uRL);
   setParameter(std::string("TranscodeParams") + ".Background.RenderMode", transcodeParams.background.renderMode);
+  setParameter(std::string("TranscodeParams") + ".Background.URL", transcodeParams.background.uRL);
   for(int dep1 = 0; dep1 != transcodeParams.userInfos.size(); dep1++) {
     setParameter(std::string("TranscodeParams") + ".UserInfos." + std::to_string(dep1 + 1) + ".StreamType", transcodeParams.userInfos[dep1].streamType);
     setParameter(std::string("TranscodeParams") + ".UserInfos." + std::to_string(dep1 + 1) + ".SourceType", transcodeParams.userInfos[dep1].sourceType);
@@ -84,10 +84,10 @@ void StartLiveMPUTaskRequest::setTranscodeParams(const StartLiveMPUTaskRequest::
   setParameter(std::string("TranscodeParams") + ".EncodeParams.AudioBitrate", transcodeParams.encodeParams.audioBitrate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoFramerate", transcodeParams.encodeParams.videoFramerate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoHeight", transcodeParams.encodeParams.videoHeight);
-  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoBitrate", transcodeParams.encodeParams.videoBitrate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.AudioSampleRate", transcodeParams.encodeParams.audioSampleRate);
-  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoGop", transcodeParams.encodeParams.videoGop);
+  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoBitrate", transcodeParams.encodeParams.videoBitrate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.AudioChannels", transcodeParams.encodeParams.audioChannels);
+  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoGop", transcodeParams.encodeParams.videoGop);
 }
 
 std::string StartLiveMPUTaskRequest::getAppId() const {

live/src/model/UpdateLiveMPUTaskRequest.cc

@@ -59,20 +59,20 @@ void UpdateLiveMPUTaskRequest::setTranscodeParams(const UpdateLiveMPUTaskRequest
   for(int dep1 = 0; dep1 != transcodeParams.layout.userPanes.size(); dep1++) {
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".BackgroundImageUrl", transcodeParams.layout.userPanes[dep1].backgroundImageUrl);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".ZOrder", transcodeParams.layout.userPanes[dep1].zOrder);
-    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".X", transcodeParams.layout.userPanes[dep1].x);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".Width", transcodeParams.layout.userPanes[dep1].width);
+    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".X", transcodeParams.layout.userPanes[dep1].x);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".Y", transcodeParams.layout.userPanes[dep1].y);
+    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".RenderMode", transcodeParams.layout.userPanes[dep1].renderMode);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".UserInfo.SourceType", transcodeParams.layout.userPanes[dep1].userInfo.sourceType);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".UserInfo.UserId", transcodeParams.layout.userPanes[dep1].userInfo.userId);
-    setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".RenderMode", transcodeParams.layout.userPanes[dep1].renderMode);
     setParameter(std::string("TranscodeParams") + ".Layout.UserPanes." + std::to_string(dep1 + 1) + ".Height", transcodeParams.layout.userPanes[dep1].height);
   }
   setParameter(std::string("TranscodeParams") + ".Layout.LayoutMode", transcodeParams.layout.layoutMode);
   setParameter(std::string("TranscodeParams") + ".Layout.MaxVideoUser.StreamType", transcodeParams.layout.maxVideoUser.streamType);
   setParameter(std::string("TranscodeParams") + ".Layout.MaxVideoUser.SourceType", transcodeParams.layout.maxVideoUser.sourceType);
   setParameter(std::string("TranscodeParams") + ".Layout.MaxVideoUser.UserId", transcodeParams.layout.maxVideoUser.userId);
-  setParameter(std::string("TranscodeParams") + ".Background.URL", transcodeParams.background.uRL);
   setParameter(std::string("TranscodeParams") + ".Background.RenderMode", transcodeParams.background.renderMode);
+  setParameter(std::string("TranscodeParams") + ".Background.URL", transcodeParams.background.uRL);
   for(int dep1 = 0; dep1 != transcodeParams.userInfos.size(); dep1++) {
     setParameter(std::string("TranscodeParams") + ".UserInfos." + std::to_string(dep1 + 1) + ".StreamType", transcodeParams.userInfos[dep1].streamType);
     setParameter(std::string("TranscodeParams") + ".UserInfos." + std::to_string(dep1 + 1) + ".SourceType", transcodeParams.userInfos[dep1].sourceType);
@@ -83,10 +83,10 @@ void UpdateLiveMPUTaskRequest::setTranscodeParams(const UpdateLiveMPUTaskRequest
   setParameter(std::string("TranscodeParams") + ".EncodeParams.AudioBitrate", transcodeParams.encodeParams.audioBitrate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoFramerate", transcodeParams.encodeParams.videoFramerate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoHeight", transcodeParams.encodeParams.videoHeight);
-  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoBitrate", transcodeParams.encodeParams.videoBitrate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.AudioSampleRate", transcodeParams.encodeParams.audioSampleRate);
-  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoGop", transcodeParams.encodeParams.videoGop);
+  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoBitrate", transcodeParams.encodeParams.videoBitrate);
   setParameter(std::string("TranscodeParams") + ".EncodeParams.AudioChannels", transcodeParams.encodeParams.audioChannels);
+  setParameter(std::string("TranscodeParams") + ".EncodeParams.VideoGop", transcodeParams.encodeParams.videoGop);
 }
 
 std::string UpdateLiveMPUTaskRequest::getAppId() const {