VOD SDK Auto Released By guzhaoyuan,Version：1.33.2

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

vod/src/VodClient.cc

@@ -771,6 +771,42 @@ VodClient::DescribeRefreshTasksOutcomeCallable VodClient::describeRefreshTasksCa
 	return task->get_future();
 }
 
+VodClient::DeleteWatermarkOutcome VodClient::deleteWatermark(const DeleteWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteWatermarkOutcome(DeleteWatermarkResult(outcome.result()));
+	else
+		return DeleteWatermarkOutcome(outcome.error());
+}
+
+void VodClient::deleteWatermarkAsync(const DeleteWatermarkRequest& request, const DeleteWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::DeleteWatermarkOutcomeCallable VodClient::deleteWatermarkCallable(const DeleteWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::UpdateCategoryOutcome VodClient::updateCategory(const UpdateCategoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +843,42 @@ VodClient::UpdateCategoryOutcomeCallable VodClient::updateCategoryCallable(const
 	return task->get_future();
 }
 
+VodClient::RegisterMediaOutcome VodClient::registerMedia(const RegisterMediaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RegisterMediaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RegisterMediaOutcome(RegisterMediaResult(outcome.result()));
+	else
+		return RegisterMediaOutcome(outcome.error());
+}
+
+void VodClient::registerMediaAsync(const RegisterMediaRequest& request, const RegisterMediaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, registerMedia(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::RegisterMediaOutcomeCallable VodClient::registerMediaCallable(const RegisterMediaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RegisterMediaOutcome()>>(
+			[this, request]()
+			{
+			return this->registerMedia(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::ListAIASRJobOutcome VodClient::listAIASRJob(const ListAIASRJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -878,6 +950,7 @@ VodClient::ListAIVideoCensorJobOutcomeCallable VodClient::listAIVideoCensorJobCa
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
+
 
 VodClient::DescribeRefreshQuotaOutcome VodClient::describeRefreshQuota(const DescribeRefreshQuotaRequest &request) const
 {
@@ -1203,6 +1276,78 @@ VodClient::GetVideoConfigOutcomeCallable VodClient::getVideoConfigCallable(const
 	return task->get_future();
 }
 
+VodClient::AddWatermarkOutcome VodClient::addWatermark(const AddWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddWatermarkOutcome(AddWatermarkResult(outcome.result()));
+	else
+		return AddWatermarkOutcome(outcome.error());
+}
+
+void VodClient::addWatermarkAsync(const AddWatermarkRequest& request, const AddWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::AddWatermarkOutcomeCallable VodClient::addWatermarkCallable(const AddWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->addWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+VodClient::ListWatermarkOutcome VodClient::listWatermark(const ListWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListWatermarkOutcome(ListWatermarkResult(outcome.result()));
+	else
+		return ListWatermarkOutcome(outcome.error());
+}
+
+void VodClient::listWatermarkAsync(const ListWatermarkRequest& request, const ListWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::ListWatermarkOutcomeCallable VodClient::listWatermarkCallable(const ListWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->listWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::CreateUploadImageOutcome VodClient::createUploadImage(const CreateUploadImageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1528,42 @@ VodClient::DescribePlayTopVideosOutcomeCallable VodClient::describePlayTopVideos
 	return task->get_future();
 }
 
+VodClient::SetDefaultWatermarkOutcome VodClient::setDefaultWatermark(const SetDefaultWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetDefaultWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetDefaultWatermarkOutcome(SetDefaultWatermarkResult(outcome.result()));
+	else
+		return SetDefaultWatermarkOutcome(outcome.error());
+}
+
+void VodClient::setDefaultWatermarkAsync(const SetDefaultWatermarkRequest& request, const SetDefaultWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setDefaultWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::SetDefaultWatermarkOutcomeCallable VodClient::setDefaultWatermarkCallable(const SetDefaultWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetDefaultWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->setDefaultWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::PushObjectCacheOutcome VodClient::pushObjectCache(const PushObjectCacheRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1779,6 +1960,78 @@ VodClient::SearchEditingProjectOutcomeCallable VodClient::searchEditingProjectCa
 	return task->get_future();
 }
 
+VodClient::GetWatermarkOutcome VodClient::getWatermark(const GetWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetWatermarkOutcome(GetWatermarkResult(outcome.result()));
+	else
+		return GetWatermarkOutcome(outcome.error());
+}
+
+void VodClient::getWatermarkAsync(const GetWatermarkRequest& request, const GetWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::GetWatermarkOutcomeCallable VodClient::getWatermarkCallable(const GetWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->getWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+VodClient::UpdateWatermarkOutcome VodClient::updateWatermark(const UpdateWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateWatermarkOutcome(UpdateWatermarkResult(outcome.result()));
+	else
+		return UpdateWatermarkOutcome(outcome.error());
+}
+
+void VodClient::updateWatermarkAsync(const UpdateWatermarkRequest& request, const UpdateWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::UpdateWatermarkOutcomeCallable VodClient::updateWatermarkCallable(const UpdateWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->updateWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::GetImageInfoOutcome VodClient::getImageInfo(const GetImageInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

vod/src/model/AddWatermarkRequest.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vod/model/AddWatermarkRequest.h>
+
+using AlibabaCloud::Vod::Model::AddWatermarkRequest;
+
+AddWatermarkRequest::AddWatermarkRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "AddWatermark")
+{}
+
+AddWatermarkRequest::~AddWatermarkRequest()
+{}
+
+long AddWatermarkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void AddWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string AddWatermarkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void AddWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string AddWatermarkRequest::getName()const
+{
+	return name_;
+}
+
+void AddWatermarkRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string AddWatermarkRequest::getFileUrl()const
+{
+	return fileUrl_;
+}
+
+void AddWatermarkRequest::setFileUrl(const std::string& fileUrl)
+{
+	fileUrl_ = fileUrl;
+	setParameter("FileUrl", fileUrl);
+}
+
+long AddWatermarkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddWatermarkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string AddWatermarkRequest::getType()const
+{
+	return type_;
+}
+
+void AddWatermarkRequest::setType(const std::string& type)
+{
+	type_ = type;
+	setParameter("Type", type);
+}
+
+std::string AddWatermarkRequest::getWatermarkConfig()const
+{
+	return watermarkConfig_;
+}
+
+void AddWatermarkRequest::setWatermarkConfig(const std::string& watermarkConfig)
+{
+	watermarkConfig_ = watermarkConfig;
+	setParameter("WatermarkConfig", watermarkConfig);
+}
+
+std::string AddWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

vod/src/model/AddWatermarkResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/vod/model/AddWatermarkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+AddWatermarkResult::AddWatermarkResult() :
+	ServiceResult()
+{}
+
+AddWatermarkResult::AddWatermarkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddWatermarkResult::~AddWatermarkResult()
+{}
+
+void AddWatermarkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto watermarkInfoNode = value["WatermarkInfo"];
+	if(!watermarkInfoNode["CreationTime"].isNull())
+		watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString();
+	if(!watermarkInfoNode["Type"].isNull())
+		watermarkInfo_.type = watermarkInfoNode["Type"].asString();
+	if(!watermarkInfoNode["IsDefault"].isNull())
+		watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString();
+	if(!watermarkInfoNode["WatermarkId"].isNull())
+		watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString();
+	if(!watermarkInfoNode["Name"].isNull())
+		watermarkInfo_.name = watermarkInfoNode["Name"].asString();
+	if(!watermarkInfoNode["FileUrl"].isNull())
+		watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
+	if(!watermarkInfoNode["WatermarkConfig"].isNull())
+		watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
+
+}
+
+AddWatermarkResult::WatermarkInfo AddWatermarkResult::getWatermarkInfo()const
+{
+	return watermarkInfo_;
+}
+

vod/src/model/DeleteWatermarkRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * 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/vod/model/DeleteWatermarkRequest.h>
+
+using AlibabaCloud::Vod::Model::DeleteWatermarkRequest;
+
+DeleteWatermarkRequest::DeleteWatermarkRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "DeleteWatermark")
+{}
+
+DeleteWatermarkRequest::~DeleteWatermarkRequest()
+{}
+
+std::string DeleteWatermarkRequest::getWatermarkId()const
+{
+	return watermarkId_;
+}
+
+void DeleteWatermarkRequest::setWatermarkId(const std::string& watermarkId)
+{
+	watermarkId_ = watermarkId;
+	setParameter("WatermarkId", watermarkId);
+}
+
+long DeleteWatermarkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteWatermarkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long DeleteWatermarkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteWatermarkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

vod/src/model/GetVideoListRequest.cc

@@ -135,3 +135,14 @@ void GetVideoListRequest::setStatus(const std::string& status)
 	setParameter("Status", status);
 }
 
+std::string GetVideoListRequest::getStorageLocation()const
+{
+	return storageLocation_;
+}
+
+void GetVideoListRequest::setStorageLocation(const std::string& storageLocation)
+{
+	storageLocation_ = storageLocation;
+	setParameter("StorageLocation", storageLocation);
+}
+

vod/src/model/GetVideoListResult.cc

@@ -72,6 +72,8 @@ void GetVideoListResult::parse(const std::string &payload)
 			videoListObject.cateId = std::stol(value["CateId"].asString());
 		if(!value["CateName"].isNull())
 			videoListObject.cateName = value["CateName"].asString();
+		if(!value["StorageLocation"].isNull())
+			videoListObject.storageLocation = value["StorageLocation"].asString();
 		auto allSnapshots = value["Snapshots"]["Snapshot"];
 		for (auto value : allSnapshots)
 			videoListObject.snapshots.push_back(value.asString());

vod/src/model/GetWatermarkRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * 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/vod/model/GetWatermarkRequest.h>
+
+using AlibabaCloud::Vod::Model::GetWatermarkRequest;
+
+GetWatermarkRequest::GetWatermarkRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "GetWatermark")
+{}
+
+GetWatermarkRequest::~GetWatermarkRequest()
+{}
+
+std::string GetWatermarkRequest::getWatermarkId()const
+{
+	return watermarkId_;
+}
+
+void GetWatermarkRequest::setWatermarkId(const std::string& watermarkId)
+{
+	watermarkId_ = watermarkId;
+	setParameter("WatermarkId", watermarkId);
+}
+
+long GetWatermarkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void GetWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string GetWatermarkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void GetWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long GetWatermarkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void GetWatermarkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string GetWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

vod/src/model/GetWatermarkResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/vod/model/GetWatermarkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+GetWatermarkResult::GetWatermarkResult() :
+	ServiceResult()
+{}
+
+GetWatermarkResult::GetWatermarkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetWatermarkResult::~GetWatermarkResult()
+{}
+
+void GetWatermarkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto watermarkInfoNode = value["WatermarkInfo"];
+	if(!watermarkInfoNode["CreationTime"].isNull())
+		watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString();
+	if(!watermarkInfoNode["Type"].isNull())
+		watermarkInfo_.type = watermarkInfoNode["Type"].asString();
+	if(!watermarkInfoNode["IsDefault"].isNull())
+		watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString();
+	if(!watermarkInfoNode["WatermarkId"].isNull())
+		watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString();
+	if(!watermarkInfoNode["Name"].isNull())
+		watermarkInfo_.name = watermarkInfoNode["Name"].asString();
+	if(!watermarkInfoNode["FileUrl"].isNull())
+		watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
+	if(!watermarkInfoNode["WatermarkConfig"].isNull())
+		watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
+
+}
+
+GetWatermarkResult::WatermarkInfo GetWatermarkResult::getWatermarkInfo()const
+{
+	return watermarkInfo_;
+}
+

vod/src/model/ListWatermarkRequest.cc

@@ -0,0 +1,71 @@
+/*
+ * 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/vod/model/ListWatermarkRequest.h>
+
+using AlibabaCloud::Vod::Model::ListWatermarkRequest;
+
+ListWatermarkRequest::ListWatermarkRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "ListWatermark")
+{}
+
+ListWatermarkRequest::~ListWatermarkRequest()
+{}
+
+long ListWatermarkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ListWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ListWatermarkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ListWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long ListWatermarkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ListWatermarkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ListWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ListWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

vod/src/model/ListWatermarkResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/vod/model/ListWatermarkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+ListWatermarkResult::ListWatermarkResult() :
+	ServiceResult()
+{}
+
+ListWatermarkResult::ListWatermarkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListWatermarkResult::~ListWatermarkResult()
+{}
+
+void ListWatermarkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allWatermarkInfos = value["WatermarkInfos"]["WatermarkInfo"];
+	for (auto value : allWatermarkInfos)
+	{
+		WatermarkInfo watermarkInfosObject;
+		if(!value["CreationTime"].isNull())
+			watermarkInfosObject.creationTime = value["CreationTime"].asString();
+		if(!value["Type"].isNull())
+			watermarkInfosObject.type = value["Type"].asString();
+		if(!value["IsDefault"].isNull())
+			watermarkInfosObject.isDefault = value["IsDefault"].asString();
+		if(!value["WatermarkId"].isNull())
+			watermarkInfosObject.watermarkId = value["WatermarkId"].asString();
+		if(!value["Name"].isNull())
+			watermarkInfosObject.name = value["Name"].asString();
+		if(!value["FileUrl"].isNull())
+			watermarkInfosObject.fileUrl = value["FileUrl"].asString();
+		if(!value["WatermarkConfig"].isNull())
+			watermarkInfosObject.watermarkConfig = value["WatermarkConfig"].asString();
+		watermarkInfos_.push_back(watermarkInfosObject);
+	}
+
+}
+
+std::vector<ListWatermarkResult::WatermarkInfo> ListWatermarkResult::getWatermarkInfos()const
+{
+	return watermarkInfos_;
+}
+

vod/src/model/RegisterMediaRequest.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vod/model/RegisterMediaRequest.h>
+
+using AlibabaCloud::Vod::Model::RegisterMediaRequest;
+
+RegisterMediaRequest::RegisterMediaRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "RegisterMedia")
+{}
+
+RegisterMediaRequest::~RegisterMediaRequest()
+{}
+
+std::string RegisterMediaRequest::getUserData()const
+{
+	return userData_;
+}
+
+void RegisterMediaRequest::setUserData(const std::string& userData)
+{
+	userData_ = userData;
+	setParameter("UserData", userData);
+}
+
+long RegisterMediaRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void RegisterMediaRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string RegisterMediaRequest::getTemplateGroupId()const
+{
+	return templateGroupId_;
+}
+
+void RegisterMediaRequest::setTemplateGroupId(const std::string& templateGroupId)
+{
+	templateGroupId_ = templateGroupId;
+	setParameter("TemplateGroupId", templateGroupId);
+}
+
+std::string RegisterMediaRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void RegisterMediaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long RegisterMediaRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RegisterMediaRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string RegisterMediaRequest::getRegisterMetadatas()const
+{
+	return registerMetadatas_;
+}
+
+void RegisterMediaRequest::setRegisterMetadatas(const std::string& registerMetadatas)
+{
+	registerMetadatas_ = registerMetadatas;
+	setParameter("RegisterMetadatas", registerMetadatas);
+}
+
+std::string RegisterMediaRequest::getWorkFlowId()const
+{
+	return workFlowId_;
+}
+
+void RegisterMediaRequest::setWorkFlowId(const std::string& workFlowId)
+{
+	workFlowId_ = workFlowId;
+	setParameter("WorkFlowId", workFlowId);
+}
+
+std::string RegisterMediaRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void RegisterMediaRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

vod/src/model/RegisterMediaResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/vod/model/RegisterMediaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+RegisterMediaResult::RegisterMediaResult() :
+	ServiceResult()
+{}
+
+RegisterMediaResult::RegisterMediaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RegisterMediaResult::~RegisterMediaResult()
+{}
+
+void RegisterMediaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allRegisteredMediaList = value["RegisteredMediaList"]["RegisteredMedia"];
+	for (auto value : allRegisteredMediaList)
+	{
+		RegisteredMedia registeredMediaListObject;
+		if(!value["MediaId"].isNull())
+			registeredMediaListObject.mediaId = value["MediaId"].asString();
+		if(!value["FileURL"].isNull())
+			registeredMediaListObject.fileURL = value["FileURL"].asString();
+		if(!value["NewRegister"].isNull())
+			registeredMediaListObject.newRegister = value["NewRegister"].asString() == "true";
+		registeredMediaList_.push_back(registeredMediaListObject);
+	}
+	auto allFailedFileURLs = value["FailedFileURLs"]["FileURL"];
+	for (const auto &item : allFailedFileURLs)
+		failedFileURLs_.push_back(item.asString());
+
+}
+
+std::vector<std::string> RegisterMediaResult::getFailedFileURLs()const
+{
+	return failedFileURLs_;
+}
+
+std::vector<RegisterMediaResult::RegisteredMedia> RegisterMediaResult::getRegisteredMediaList()const
+{
+	return registeredMediaList_;
+}
+

vod/src/model/SearchMediaResult.cc

@@ -138,6 +138,35 @@ void SearchMediaResult::parse(const std::string &payload)
 			auto allSpriteSnapshots2 = audioNode["SpriteSnapshots"]["SpriteSnapshot"];
 			for (auto value : allSpriteSnapshots2)
 				mediaListObject.audio.spriteSnapshots2.push_back(value.asString());
+		auto imageNode = value["Image"];
+		if(!imageNode["Title"].isNull())
+			mediaListObject.image.title = imageNode["Title"].asString();
+		if(!imageNode["ImageId"].isNull())
+			mediaListObject.image.imageId = imageNode["ImageId"].asString();
+		if(!imageNode["CateId"].isNull())
+			mediaListObject.image.cateId = std::stol(imageNode["CateId"].asString());
+		if(!imageNode["CateName"].isNull())
+			mediaListObject.image.cateName = imageNode["CateName"].asString();
+		if(!imageNode["Ext"].isNull())
+			mediaListObject.image.ext = imageNode["Ext"].asString();
+		if(!imageNode["CreationTime"].isNull())
+			mediaListObject.image.creationTime = imageNode["CreationTime"].asString();
+		if(!imageNode["ModificationTime"].isNull())
+			mediaListObject.image.modificationTime = imageNode["ModificationTime"].asString();
+		if(!imageNode["Tags"].isNull())
+			mediaListObject.image.tags = imageNode["Tags"].asString();
+		if(!imageNode["Type"].isNull())
+			mediaListObject.image.type = imageNode["Type"].asString();
+		if(!imageNode["URL"].isNull())
+			mediaListObject.image.uRL = imageNode["URL"].asString();
+		if(!imageNode["Status"].isNull())
+			mediaListObject.image.status = imageNode["Status"].asString();
+		if(!imageNode["Description"].isNull())
+			mediaListObject.image.description = imageNode["Description"].asString();
+		if(!imageNode["StorageLocation"].isNull())
+			mediaListObject.image.storageLocation = imageNode["StorageLocation"].asString();
+		if(!imageNode["RegionId"].isNull())
+			mediaListObject.image.regionId = imageNode["RegionId"].asString();
 		mediaList_.push_back(mediaListObject);
 	}
 	if(!value["ScrollToken"].isNull())

vod/src/model/SetDefaultWatermarkRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * 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/vod/model/SetDefaultWatermarkRequest.h>
+
+using AlibabaCloud::Vod::Model::SetDefaultWatermarkRequest;
+
+SetDefaultWatermarkRequest::SetDefaultWatermarkRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "SetDefaultWatermark")
+{}
+
+SetDefaultWatermarkRequest::~SetDefaultWatermarkRequest()
+{}
+
+std::string SetDefaultWatermarkRequest::getWatermarkId()const
+{
+	return watermarkId_;
+}
+
+void SetDefaultWatermarkRequest::setWatermarkId(const std::string& watermarkId)
+{
+	watermarkId_ = watermarkId;
+	setParameter("WatermarkId", watermarkId);
+}
+
+long SetDefaultWatermarkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetDefaultWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SetDefaultWatermarkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SetDefaultWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long SetDefaultWatermarkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetDefaultWatermarkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetDefaultWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void SetDefaultWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

vod/src/model/SubmitTranscodeJobsRequest.cc

@@ -69,6 +69,17 @@ void SubmitTranscodeJobsRequest::setVideoId(const std::string& videoId)
 	setParameter("VideoId", videoId);
 }
 
+std::string SubmitTranscodeJobsRequest::getOverrideParams()const
+{
+	return overrideParams_;
+}
+
+void SubmitTranscodeJobsRequest::setOverrideParams(const std::string& overrideParams)
+{
+	overrideParams_ = overrideParams;
+	setParameter("OverrideParams", overrideParams);
+}
+
 long SubmitTranscodeJobsRequest::getOwnerId()const
 {
 	return ownerId_;

vod/src/model/UpdateWatermarkRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * 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/vod/model/UpdateWatermarkRequest.h>
+
+using AlibabaCloud::Vod::Model::UpdateWatermarkRequest;
+
+UpdateWatermarkRequest::UpdateWatermarkRequest() :
+	RpcServiceRequest("vod", "2017-03-21", "UpdateWatermark")
+{}
+
+UpdateWatermarkRequest::~UpdateWatermarkRequest()
+{}
+
+std::string UpdateWatermarkRequest::getWatermarkId()const
+{
+	return watermarkId_;
+}
+
+void UpdateWatermarkRequest::setWatermarkId(const std::string& watermarkId)
+{
+	watermarkId_ = watermarkId;
+	setParameter("WatermarkId", watermarkId);
+}
+
+long UpdateWatermarkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void UpdateWatermarkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string UpdateWatermarkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void UpdateWatermarkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string UpdateWatermarkRequest::getName()const
+{
+	return name_;
+}
+
+void UpdateWatermarkRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+long UpdateWatermarkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void UpdateWatermarkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string UpdateWatermarkRequest::getWatermarkConfig()const
+{
+	return watermarkConfig_;
+}
+
+void UpdateWatermarkRequest::setWatermarkConfig(const std::string& watermarkConfig)
+{
+	watermarkConfig_ = watermarkConfig;
+	setParameter("WatermarkConfig", watermarkConfig);
+}
+
+std::string UpdateWatermarkRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void UpdateWatermarkRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

vod/src/model/UpdateWatermarkResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/vod/model/UpdateWatermarkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+UpdateWatermarkResult::UpdateWatermarkResult() :
+	ServiceResult()
+{}
+
+UpdateWatermarkResult::UpdateWatermarkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateWatermarkResult::~UpdateWatermarkResult()
+{}
+
+void UpdateWatermarkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto watermarkInfoNode = value["WatermarkInfo"];
+	if(!watermarkInfoNode["CreationTime"].isNull())
+		watermarkInfo_.creationTime = watermarkInfoNode["CreationTime"].asString();
+	if(!watermarkInfoNode["Type"].isNull())
+		watermarkInfo_.type = watermarkInfoNode["Type"].asString();
+	if(!watermarkInfoNode["IsDefault"].isNull())
+		watermarkInfo_.isDefault = watermarkInfoNode["IsDefault"].asString();
+	if(!watermarkInfoNode["WatermarkId"].isNull())
+		watermarkInfo_.watermarkId = watermarkInfoNode["WatermarkId"].asString();
+	if(!watermarkInfoNode["Name"].isNull())
+		watermarkInfo_.name = watermarkInfoNode["Name"].asString();
+	if(!watermarkInfoNode["FileUrl"].isNull())
+		watermarkInfo_.fileUrl = watermarkInfoNode["FileUrl"].asString();
+	if(!watermarkInfoNode["WatermarkConfig"].isNull())
+		watermarkInfo_.watermarkConfig = watermarkInfoNode["WatermarkConfig"].asString();
+
+}
+
+UpdateWatermarkResult::WatermarkInfo UpdateWatermarkResult::getWatermarkInfo()const
+{
+	return watermarkInfo_;
+}
+