Generated 2016-11-01 for live.

live/src/LiveClient.cc

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

live/src/model/AddCasterVideoResourceRequest.cc

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

live/src/model/AddLiveAppRecordConfigRequest.cc

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

live/src/model/CreateCustomTemplateRequest.cc

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

live/src/model/CreateCustomTemplateResult.cc

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

live/src/model/DeleteCustomTemplateRequest.cc

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

live/src/model/DeleteCustomTemplateResult.cc

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

live/src/model/DeleteLiveEdgeTransferRequest.cc

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

live/src/model/DeleteLiveEdgeTransferResult.cc

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

live/src/model/DescribeCasterChannelsResult.cc

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

live/src/model/DescribeCasterScenesResult.cc

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

live/src/model/DescribeCasterVideoResourcesResult.cc

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

live/src/model/DescribeLiveDomainRecordUsageDataResult.cc

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

live/src/model/DescribeLiveEdgeTransferRequest.cc

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

live/src/model/DescribeLiveEdgeTransferResult.cc

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

live/src/model/DescribeLiveIpInfoRequest.cc

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

live/src/model/DescribeLiveIpInfoResult.cc

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

live/src/model/DescribeLiveRecordConfigResult.cc

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

live/src/model/DescribeLiveStreamStateRequest.cc

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

live/src/model/DescribeLiveStreamStateResult.cc

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

live/src/model/DescribeLiveStreamsNotifyUrlConfigResult.cc

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

live/src/model/ForbidLiveCustomStreamRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/ForbidLiveCustomStreamRequest.h>
+
+using AlibabaCloud::Live::Model::ForbidLiveCustomStreamRequest;
+
+ForbidLiveCustomStreamRequest::ForbidLiveCustomStreamRequest() :
+	RpcServiceRequest("live", "2016-11-01", "ForbidLiveCustomStream")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ForbidLiveCustomStreamRequest::~ForbidLiveCustomStreamRequest()
+{}
+
+std::string ForbidLiveCustomStreamRequest::getStyp()const
+{
+	return styp_;
+}
+
+void ForbidLiveCustomStreamRequest::setStyp(const std::string& styp)
+{
+	styp_ = styp;
+	setParameter("Styp", styp);
+}
+
+std::string ForbidLiveCustomStreamRequest::getAppName()const
+{
+	return appName_;
+}
+
+void ForbidLiveCustomStreamRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setParameter("AppName", appName);
+}
+
+std::string ForbidLiveCustomStreamRequest::getStreamName()const
+{
+	return streamName_;
+}
+
+void ForbidLiveCustomStreamRequest::setStreamName(const std::string& streamName)
+{
+	streamName_ = streamName;
+	setParameter("StreamName", streamName);
+}
+
+std::string ForbidLiveCustomStreamRequest::getControlStreamAction()const
+{
+	return controlStreamAction_;
+}
+
+void ForbidLiveCustomStreamRequest::setControlStreamAction(const std::string& controlStreamAction)
+{
+	controlStreamAction_ = controlStreamAction;
+	setParameter("ControlStreamAction", controlStreamAction);
+}
+
+std::string ForbidLiveCustomStreamRequest::getNeedwm()const
+{
+	return needwm_;
+}
+
+void ForbidLiveCustomStreamRequest::setNeedwm(const std::string& needwm)
+{
+	needwm_ = needwm;
+	setParameter("Needwm", needwm);
+}
+
+std::string ForbidLiveCustomStreamRequest::getResumeTime()const
+{
+	return resumeTime_;
+}
+
+void ForbidLiveCustomStreamRequest::setResumeTime(const std::string& resumeTime)
+{
+	resumeTime_ = resumeTime;
+	setParameter("ResumeTime", resumeTime);
+}
+
+std::string ForbidLiveCustomStreamRequest::getLiveStreamType()const
+{
+	return liveStreamType_;
+}
+
+void ForbidLiveCustomStreamRequest::setLiveStreamType(const std::string& liveStreamType)
+{
+	liveStreamType_ = liveStreamType;
+	setParameter("LiveStreamType", liveStreamType);
+}
+
+std::string ForbidLiveCustomStreamRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void ForbidLiveCustomStreamRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long ForbidLiveCustomStreamRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ForbidLiveCustomStreamRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ForbidLiveCustomStreamRequest::getSphd()const
+{
+	return sphd_;
+}
+
+void ForbidLiveCustomStreamRequest::setSphd(const std::string& sphd)
+{
+	sphd_ = sphd;
+	setParameter("Sphd", sphd);
+}
+
+std::string ForbidLiveCustomStreamRequest::getOneshot()const
+{
+	return oneshot_;
+}
+
+void ForbidLiveCustomStreamRequest::setOneshot(const std::string& oneshot)
+{
+	oneshot_ = oneshot;
+	setParameter("Oneshot", oneshot);
+}
+
+std::string ForbidLiveCustomStreamRequest::getAppid()const
+{
+	return appid_;
+}
+
+void ForbidLiveCustomStreamRequest::setAppid(const std::string& appid)
+{
+	appid_ = appid;
+	setParameter("Appid", appid);
+}
+
+std::string ForbidLiveCustomStreamRequest::getRatio()const
+{
+	return ratio_;
+}
+
+void ForbidLiveCustomStreamRequest::setRatio(const std::string& ratio)
+{
+	ratio_ = ratio;
+	setParameter("Ratio", ratio);
+}
+

live/src/model/ForbidLiveCustomStreamResult.cc

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

live/src/model/GetCustomTemplateRequest.cc

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

live/src/model/GetCustomTemplateResult.cc

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

live/src/model/SetCasterChannelRequest.cc

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

live/src/model/SetCasterSyncGroupRequest.cc

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

live/src/model/SetLiveEdgeTransferRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/SetLiveEdgeTransferRequest.h>
+
+using AlibabaCloud::Live::Model::SetLiveEdgeTransferRequest;
+
+SetLiveEdgeTransferRequest::SetLiveEdgeTransferRequest() :
+	RpcServiceRequest("live", "2016-11-01", "SetLiveEdgeTransfer")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetLiveEdgeTransferRequest::~SetLiveEdgeTransferRequest()
+{}
+
+std::string SetLiveEdgeTransferRequest::getTransferArgs()const
+{
+	return transferArgs_;
+}
+
+void SetLiveEdgeTransferRequest::setTransferArgs(const std::string& transferArgs)
+{
+	transferArgs_ = transferArgs;
+	setParameter("TransferArgs", transferArgs);
+}
+
+std::string SetLiveEdgeTransferRequest::getAppName()const
+{
+	return appName_;
+}
+
+void SetLiveEdgeTransferRequest::setAppName(const std::string& appName)
+{
+	appName_ = appName;
+	setParameter("AppName", appName);
+}
+
+std::string SetLiveEdgeTransferRequest::getStreamName()const
+{
+	return streamName_;
+}
+
+void SetLiveEdgeTransferRequest::setStreamName(const std::string& streamName)
+{
+	streamName_ = streamName;
+	setParameter("StreamName", streamName);
+}
+
+std::string SetLiveEdgeTransferRequest::getTargetDomainList()const
+{
+	return targetDomainList_;
+}
+
+void SetLiveEdgeTransferRequest::setTargetDomainList(const std::string& targetDomainList)
+{
+	targetDomainList_ = targetDomainList;
+	setParameter("TargetDomainList", targetDomainList);
+}
+
+std::string SetLiveEdgeTransferRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void SetLiveEdgeTransferRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long SetLiveEdgeTransferRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetLiveEdgeTransferRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetLiveEdgeTransferRequest::getHttpDns()const
+{
+	return httpDns_;
+}
+
+void SetLiveEdgeTransferRequest::setHttpDns(const std::string& httpDns)
+{
+	httpDns_ = httpDns;
+	setParameter("HttpDns", httpDns);
+}
+

live/src/model/SetLiveEdgeTransferResult.cc

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

live/src/model/SetLiveStreamsNotifyUrlConfigRequest.cc

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

live/src/model/StartCasterRequest.cc

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

live/src/model/StartCasterResult.cc

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