VOD SDK Auto Released By guzhaoyuan,Version：1.33.2

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

CHANGELOG

@@ -1,3 +1,8 @@
+2018-11-21 Version: 1.33.2
+1, Add new apis called AddWatermark, UpdateWatermark, DeleteWatermark, ListWatermarks, GetWatermark and SetDefaultWatermark which support watermark feature.
+2, Add a new api called RegisterMedia which supports registration of audio and video media files that already exist in the OSS bucket.
+3, Add the field named OverrideParams to SubmitTranscodeJobs api request.
+
 2018-11-16 Version: 1.33.1
 1, update version
 

VERSION

@@ -1 +1 @@
-1.33.1
+1.33.2

vod/CMakeLists.txt

@@ -61,8 +61,12 @@ set(vod_public_header_model
 	include/alibabacloud/vod/model/SubmitAIVideoCategoryJobResult.h
 	include/alibabacloud/vod/model/DescribeRefreshTasksRequest.h
 	include/alibabacloud/vod/model/DescribeRefreshTasksResult.h
+	include/alibabacloud/vod/model/DeleteWatermarkRequest.h
+	include/alibabacloud/vod/model/DeleteWatermarkResult.h
 	include/alibabacloud/vod/model/UpdateCategoryRequest.h
 	include/alibabacloud/vod/model/UpdateCategoryResult.h
+	include/alibabacloud/vod/model/RegisterMediaRequest.h
+	include/alibabacloud/vod/model/RegisterMediaResult.h
 	include/alibabacloud/vod/model/ListAIASRJobRequest.h
 	include/alibabacloud/vod/model/ListAIASRJobResult.h
 	include/alibabacloud/vod/model/ListAIVideoCensorJobRequest.h
@@ -85,6 +89,10 @@ set(vod_public_header_model
 	include/alibabacloud/vod/model/ListAIJobResult.h
 	include/alibabacloud/vod/model/GetVideoConfigRequest.h
 	include/alibabacloud/vod/model/GetVideoConfigResult.h
+	include/alibabacloud/vod/model/AddWatermarkRequest.h
+	include/alibabacloud/vod/model/AddWatermarkResult.h
+	include/alibabacloud/vod/model/ListWatermarkRequest.h
+	include/alibabacloud/vod/model/ListWatermarkResult.h
 	include/alibabacloud/vod/model/CreateUploadImageRequest.h
 	include/alibabacloud/vod/model/CreateUploadImageResult.h
 	include/alibabacloud/vod/model/UpdateVideoInfoRequest.h
@@ -95,6 +103,8 @@ set(vod_public_header_model
 	include/alibabacloud/vod/model/SearchMediaResult.h
 	include/alibabacloud/vod/model/DescribePlayTopVideosRequest.h
 	include/alibabacloud/vod/model/DescribePlayTopVideosResult.h
+	include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h
+	include/alibabacloud/vod/model/SetDefaultWatermarkResult.h
 	include/alibabacloud/vod/model/PushObjectCacheRequest.h
 	include/alibabacloud/vod/model/PushObjectCacheResult.h
 	include/alibabacloud/vod/model/AddCategoryRequest.h
@@ -117,6 +127,10 @@ set(vod_public_header_model
 	include/alibabacloud/vod/model/SubmitAIVideoTerrorismRecogJobResult.h
 	include/alibabacloud/vod/model/SearchEditingProjectRequest.h
 	include/alibabacloud/vod/model/SearchEditingProjectResult.h
+	include/alibabacloud/vod/model/GetWatermarkRequest.h
+	include/alibabacloud/vod/model/GetWatermarkResult.h
+	include/alibabacloud/vod/model/UpdateWatermarkRequest.h
+	include/alibabacloud/vod/model/UpdateWatermarkResult.h
 	include/alibabacloud/vod/model/GetImageInfoRequest.h
 	include/alibabacloud/vod/model/GetImageInfoResult.h
 	include/alibabacloud/vod/model/GetMessageCallbackRequest.h
@@ -214,8 +228,12 @@ set(vod_src
 	src/model/SubmitAIVideoCategoryJobResult.cc
 	src/model/DescribeRefreshTasksRequest.cc
 	src/model/DescribeRefreshTasksResult.cc
+	src/model/DeleteWatermarkRequest.cc
+	src/model/DeleteWatermarkResult.cc
 	src/model/UpdateCategoryRequest.cc
 	src/model/UpdateCategoryResult.cc
+	src/model/RegisterMediaRequest.cc
+	src/model/RegisterMediaResult.cc
 	src/model/ListAIASRJobRequest.cc
 	src/model/ListAIASRJobResult.cc
 	src/model/ListAIVideoCensorJobRequest.cc
@@ -238,6 +256,10 @@ set(vod_src
 	src/model/ListAIJobResult.cc
 	src/model/GetVideoConfigRequest.cc
 	src/model/GetVideoConfigResult.cc
+	src/model/AddWatermarkRequest.cc
+	src/model/AddWatermarkResult.cc
+	src/model/ListWatermarkRequest.cc
+	src/model/ListWatermarkResult.cc
 	src/model/CreateUploadImageRequest.cc
 	src/model/CreateUploadImageResult.cc
 	src/model/UpdateVideoInfoRequest.cc
@@ -248,6 +270,8 @@ set(vod_src
 	src/model/SearchMediaResult.cc
 	src/model/DescribePlayTopVideosRequest.cc
 	src/model/DescribePlayTopVideosResult.cc
+	src/model/SetDefaultWatermarkRequest.cc
+	src/model/SetDefaultWatermarkResult.cc
 	src/model/PushObjectCacheRequest.cc
 	src/model/PushObjectCacheResult.cc
 	src/model/AddCategoryRequest.cc
@@ -270,6 +294,10 @@ set(vod_src
 	src/model/SubmitAIVideoTerrorismRecogJobResult.cc
 	src/model/SearchEditingProjectRequest.cc
 	src/model/SearchEditingProjectResult.cc
+	src/model/GetWatermarkRequest.cc
+	src/model/GetWatermarkResult.cc
+	src/model/UpdateWatermarkRequest.cc
+	src/model/UpdateWatermarkResult.cc
 	src/model/GetImageInfoRequest.cc
 	src/model/GetImageInfoResult.cc
 	src/model/GetMessageCallbackRequest.cc

vod/include/alibabacloud/vod/VodClient.h

@@ -62,8 +62,12 @@
 #include "model/SubmitAIVideoCategoryJobResult.h"
 #include "model/DescribeRefreshTasksRequest.h"
 #include "model/DescribeRefreshTasksResult.h"
+#include "model/DeleteWatermarkRequest.h"
+#include "model/DeleteWatermarkResult.h"
 #include "model/UpdateCategoryRequest.h"
 #include "model/UpdateCategoryResult.h"
+#include "model/RegisterMediaRequest.h"
+#include "model/RegisterMediaResult.h"
 #include "model/ListAIASRJobRequest.h"
 #include "model/ListAIASRJobResult.h"
 #include "model/ListAIVideoCensorJobRequest.h"
@@ -86,6 +90,10 @@
 #include "model/ListAIJobResult.h"
 #include "model/GetVideoConfigRequest.h"
 #include "model/GetVideoConfigResult.h"
+#include "model/AddWatermarkRequest.h"
+#include "model/AddWatermarkResult.h"
+#include "model/ListWatermarkRequest.h"
+#include "model/ListWatermarkResult.h"
 #include "model/CreateUploadImageRequest.h"
 #include "model/CreateUploadImageResult.h"
 #include "model/UpdateVideoInfoRequest.h"
@@ -96,6 +104,8 @@
 #include "model/SearchMediaResult.h"
 #include "model/DescribePlayTopVideosRequest.h"
 #include "model/DescribePlayTopVideosResult.h"
+#include "model/SetDefaultWatermarkRequest.h"
+#include "model/SetDefaultWatermarkResult.h"
 #include "model/PushObjectCacheRequest.h"
 #include "model/PushObjectCacheResult.h"
 #include "model/AddCategoryRequest.h"
@@ -118,6 +128,10 @@
 #include "model/SubmitAIVideoTerrorismRecogJobResult.h"
 #include "model/SearchEditingProjectRequest.h"
 #include "model/SearchEditingProjectResult.h"
+#include "model/GetWatermarkRequest.h"
+#include "model/GetWatermarkResult.h"
+#include "model/UpdateWatermarkRequest.h"
+#include "model/UpdateWatermarkResult.h"
 #include "model/GetImageInfoRequest.h"
 #include "model/GetImageInfoResult.h"
 #include "model/GetMessageCallbackRequest.h"
@@ -241,9 +255,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeRefreshTasksResult> DescribeRefreshTasksOutcome;
 			typedef std::future<DescribeRefreshTasksOutcome> DescribeRefreshTasksOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::DescribeRefreshTasksRequest&, const DescribeRefreshTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRefreshTasksAsyncHandler;
+			typedef Outcome<Error, Model::DeleteWatermarkResult> DeleteWatermarkOutcome;
+			typedef std::future<DeleteWatermarkOutcome> DeleteWatermarkOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::DeleteWatermarkRequest&, const DeleteWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteWatermarkAsyncHandler;
 			typedef Outcome<Error, Model::UpdateCategoryResult> UpdateCategoryOutcome;
 			typedef std::future<UpdateCategoryOutcome> UpdateCategoryOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::UpdateCategoryRequest&, const UpdateCategoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCategoryAsyncHandler;
+			typedef Outcome<Error, Model::RegisterMediaResult> RegisterMediaOutcome;
+			typedef std::future<RegisterMediaOutcome> RegisterMediaOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::RegisterMediaRequest&, const RegisterMediaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterMediaAsyncHandler;
 			typedef Outcome<Error, Model::ListAIASRJobResult> ListAIASRJobOutcome;
 			typedef std::future<ListAIASRJobOutcome> ListAIASRJobOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::ListAIASRJobRequest&, const ListAIASRJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAIASRJobAsyncHandler;
@@ -277,6 +297,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetVideoConfigResult> GetVideoConfigOutcome;
 			typedef std::future<GetVideoConfigOutcome> GetVideoConfigOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::GetVideoConfigRequest&, const GetVideoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVideoConfigAsyncHandler;
+			typedef Outcome<Error, Model::AddWatermarkResult> AddWatermarkOutcome;
+			typedef std::future<AddWatermarkOutcome> AddWatermarkOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::AddWatermarkRequest&, const AddWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddWatermarkAsyncHandler;
+			typedef Outcome<Error, Model::ListWatermarkResult> ListWatermarkOutcome;
+			typedef std::future<ListWatermarkOutcome> ListWatermarkOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::ListWatermarkRequest&, const ListWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListWatermarkAsyncHandler;
 			typedef Outcome<Error, Model::CreateUploadImageResult> CreateUploadImageOutcome;
 			typedef std::future<CreateUploadImageOutcome> CreateUploadImageOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::CreateUploadImageRequest&, const CreateUploadImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUploadImageAsyncHandler;
@@ -292,6 +318,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribePlayTopVideosResult> DescribePlayTopVideosOutcome;
 			typedef std::future<DescribePlayTopVideosOutcome> DescribePlayTopVideosOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::DescribePlayTopVideosRequest&, const DescribePlayTopVideosOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePlayTopVideosAsyncHandler;
+			typedef Outcome<Error, Model::SetDefaultWatermarkResult> SetDefaultWatermarkOutcome;
+			typedef std::future<SetDefaultWatermarkOutcome> SetDefaultWatermarkOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::SetDefaultWatermarkRequest&, const SetDefaultWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDefaultWatermarkAsyncHandler;
 			typedef Outcome<Error, Model::PushObjectCacheResult> PushObjectCacheOutcome;
 			typedef std::future<PushObjectCacheOutcome> PushObjectCacheOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::PushObjectCacheRequest&, const PushObjectCacheOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushObjectCacheAsyncHandler;
@@ -325,6 +354,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SearchEditingProjectResult> SearchEditingProjectOutcome;
 			typedef std::future<SearchEditingProjectOutcome> SearchEditingProjectOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::SearchEditingProjectRequest&, const SearchEditingProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchEditingProjectAsyncHandler;
+			typedef Outcome<Error, Model::GetWatermarkResult> GetWatermarkOutcome;
+			typedef std::future<GetWatermarkOutcome> GetWatermarkOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::GetWatermarkRequest&, const GetWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWatermarkAsyncHandler;
+			typedef Outcome<Error, Model::UpdateWatermarkResult> UpdateWatermarkOutcome;
+			typedef std::future<UpdateWatermarkOutcome> UpdateWatermarkOutcomeCallable;
+			typedef std::function<void(const VodClient*, const Model::UpdateWatermarkRequest&, const UpdateWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateWatermarkAsyncHandler;
 			typedef Outcome<Error, Model::GetImageInfoResult> GetImageInfoOutcome;
 			typedef std::future<GetImageInfoOutcome> GetImageInfoOutcomeCallable;
 			typedef std::function<void(const VodClient*, const Model::GetImageInfoRequest&, const GetImageInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetImageInfoAsyncHandler;
@@ -471,9 +506,15 @@ namespace AlibabaCloud
 			DescribeRefreshTasksOutcome describeRefreshTasks(const Model::DescribeRefreshTasksRequest &request)const;
 			void describeRefreshTasksAsync(const Model::DescribeRefreshTasksRequest& request, const DescribeRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRefreshTasksOutcomeCallable describeRefreshTasksCallable(const Model::DescribeRefreshTasksRequest& request) const;
+			DeleteWatermarkOutcome deleteWatermark(const Model::DeleteWatermarkRequest &request)const;
+			void deleteWatermarkAsync(const Model::DeleteWatermarkRequest& request, const DeleteWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteWatermarkOutcomeCallable deleteWatermarkCallable(const Model::DeleteWatermarkRequest& request) const;
 			UpdateCategoryOutcome updateCategory(const Model::UpdateCategoryRequest &request)const;
 			void updateCategoryAsync(const Model::UpdateCategoryRequest& request, const UpdateCategoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateCategoryOutcomeCallable updateCategoryCallable(const Model::UpdateCategoryRequest& request) const;
+			RegisterMediaOutcome registerMedia(const Model::RegisterMediaRequest &request)const;
+			void registerMediaAsync(const Model::RegisterMediaRequest& request, const RegisterMediaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RegisterMediaOutcomeCallable registerMediaCallable(const Model::RegisterMediaRequest& request) const;
 			ListAIASRJobOutcome listAIASRJob(const Model::ListAIASRJobRequest &request)const;
 			void listAIASRJobAsync(const Model::ListAIASRJobRequest& request, const ListAIASRJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAIASRJobOutcomeCallable listAIASRJobCallable(const Model::ListAIASRJobRequest& request) const;
@@ -507,6 +548,12 @@ namespace AlibabaCloud
 			GetVideoConfigOutcome getVideoConfig(const Model::GetVideoConfigRequest &request)const;
 			void getVideoConfigAsync(const Model::GetVideoConfigRequest& request, const GetVideoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVideoConfigOutcomeCallable getVideoConfigCallable(const Model::GetVideoConfigRequest& request) const;
+			AddWatermarkOutcome addWatermark(const Model::AddWatermarkRequest &request)const;
+			void addWatermarkAsync(const Model::AddWatermarkRequest& request, const AddWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddWatermarkOutcomeCallable addWatermarkCallable(const Model::AddWatermarkRequest& request) const;
+			ListWatermarkOutcome listWatermark(const Model::ListWatermarkRequest &request)const;
+			void listWatermarkAsync(const Model::ListWatermarkRequest& request, const ListWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListWatermarkOutcomeCallable listWatermarkCallable(const Model::ListWatermarkRequest& request) const;
 			CreateUploadImageOutcome createUploadImage(const Model::CreateUploadImageRequest &request)const;
 			void createUploadImageAsync(const Model::CreateUploadImageRequest& request, const CreateUploadImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateUploadImageOutcomeCallable createUploadImageCallable(const Model::CreateUploadImageRequest& request) const;
@@ -522,6 +569,9 @@ namespace AlibabaCloud
 			DescribePlayTopVideosOutcome describePlayTopVideos(const Model::DescribePlayTopVideosRequest &request)const;
 			void describePlayTopVideosAsync(const Model::DescribePlayTopVideosRequest& request, const DescribePlayTopVideosAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePlayTopVideosOutcomeCallable describePlayTopVideosCallable(const Model::DescribePlayTopVideosRequest& request) const;
+			SetDefaultWatermarkOutcome setDefaultWatermark(const Model::SetDefaultWatermarkRequest &request)const;
+			void setDefaultWatermarkAsync(const Model::SetDefaultWatermarkRequest& request, const SetDefaultWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetDefaultWatermarkOutcomeCallable setDefaultWatermarkCallable(const Model::SetDefaultWatermarkRequest& request) const;
 			PushObjectCacheOutcome pushObjectCache(const Model::PushObjectCacheRequest &request)const;
 			void pushObjectCacheAsync(const Model::PushObjectCacheRequest& request, const PushObjectCacheAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PushObjectCacheOutcomeCallable pushObjectCacheCallable(const Model::PushObjectCacheRequest& request) const;
@@ -555,6 +605,12 @@ namespace AlibabaCloud
 			SearchEditingProjectOutcome searchEditingProject(const Model::SearchEditingProjectRequest &request)const;
 			void searchEditingProjectAsync(const Model::SearchEditingProjectRequest& request, const SearchEditingProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SearchEditingProjectOutcomeCallable searchEditingProjectCallable(const Model::SearchEditingProjectRequest& request) const;
+			GetWatermarkOutcome getWatermark(const Model::GetWatermarkRequest &request)const;
+			void getWatermarkAsync(const Model::GetWatermarkRequest& request, const GetWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetWatermarkOutcomeCallable getWatermarkCallable(const Model::GetWatermarkRequest& request) const;
+			UpdateWatermarkOutcome updateWatermark(const Model::UpdateWatermarkRequest &request)const;
+			void updateWatermarkAsync(const Model::UpdateWatermarkRequest& request, const UpdateWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateWatermarkOutcomeCallable updateWatermarkCallable(const Model::UpdateWatermarkRequest& request) const;
 			GetImageInfoOutcome getImageInfo(const Model::GetImageInfoRequest &request)const;
 			void getImageInfoAsync(const Model::GetImageInfoRequest& request, const GetImageInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetImageInfoOutcomeCallable getImageInfoCallable(const Model::GetImageInfoRequest& request) const;

vod/include/alibabacloud/vod/model/AddWatermarkRequest.h

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

vod/include/alibabacloud/vod/model/AddWatermarkResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT AddWatermarkResult : public ServiceResult
+			{
+			public:
+				struct WatermarkInfo
+				{
+					std::string isDefault;
+					std::string fileUrl;
+					std::string type;
+					std::string watermarkId;
+					std::string creationTime;
+					std::string watermarkConfig;
+					std::string name;
+				};
+
+
+				AddWatermarkResult();
+				explicit AddWatermarkResult(const std::string &payload);
+				~AddWatermarkResult();
+				WatermarkInfo getWatermarkInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				WatermarkInfo watermarkInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_ADDWATERMARKRESULT_H_

vod/include/alibabacloud/vod/model/DeleteMezzaninesRequest.h

@@ -50,7 +50,6 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string resourceOwnerAccount_;
 				bool force_;
-				long resourceRealOwnerId_;
 				long ownerId_;
 				std::string videoIds_;
 

vod/include/alibabacloud/vod/model/DeleteWatermarkRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_
+#define ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT DeleteWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteWatermarkRequest();
+				~DeleteWatermarkRequest();
+
+				std::string getWatermarkId()const;
+				void setWatermarkId(const std::string& watermarkId);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string watermarkId_;
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKREQUEST_H_

vod/include/alibabacloud/vod/model/DeleteWatermarkResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT DeleteWatermarkResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteWatermarkResult();
+				explicit DeleteWatermarkResult(const std::string &payload);
+				~DeleteWatermarkResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_DELETEWATERMARKRESULT_H_

vod/include/alibabacloud/vod/model/GetVideoListRequest.h

@@ -55,6 +55,8 @@ namespace AlibabaCloud
 				void setOwnerId(long ownerId);
 				std::string getStatus()const;
 				void setStatus(const std::string& status);
+				std::string getStorageLocation()const;
+				void setStorageLocation(const std::string& storageLocation);
 
             private:
 				long resourceOwnerId_;
@@ -67,6 +69,7 @@ namespace AlibabaCloud
 				std::string startTime_;
 				long ownerId_;
 				std::string status_;
+				std::string storageLocation_;
 
 			};
 		}

vod/include/alibabacloud/vod/model/GetVideoListResult.h

@@ -47,6 +47,7 @@ namespace AlibabaCloud
 					std::string cateName;
 					std::string creationTime;
 					std::string coverURL;
+					std::string storageLocation;
 					std::vector<std::string> snapshots;
 					std::string tags;
 				};

vod/include/alibabacloud/vod/model/GetWatermarkRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_
+#define ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT GetWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetWatermarkRequest();
+				~GetWatermarkRequest();
+
+				std::string getWatermarkId()const;
+				void setWatermarkId(const std::string& watermarkId);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string watermarkId_;
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_GETWATERMARKREQUEST_H_

vod/include/alibabacloud/vod/model/GetWatermarkResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT GetWatermarkResult : public ServiceResult
+			{
+			public:
+				struct WatermarkInfo
+				{
+					std::string isDefault;
+					std::string fileUrl;
+					std::string type;
+					std::string watermarkId;
+					std::string creationTime;
+					std::string watermarkConfig;
+					std::string name;
+				};
+
+
+				GetWatermarkResult();
+				explicit GetWatermarkResult(const std::string &payload);
+				~GetWatermarkResult();
+				WatermarkInfo getWatermarkInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				WatermarkInfo watermarkInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_GETWATERMARKRESULT_H_

vod/include/alibabacloud/vod/model/ListWatermarkRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_
+#define ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT ListWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListWatermarkRequest();
+				~ListWatermarkRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_LISTWATERMARKREQUEST_H_

vod/include/alibabacloud/vod/model/ListWatermarkResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT ListWatermarkResult : public ServiceResult
+			{
+			public:
+				struct WatermarkInfo
+				{
+					std::string isDefault;
+					std::string fileUrl;
+					std::string type;
+					std::string watermarkId;
+					std::string creationTime;
+					std::string watermarkConfig;
+					std::string name;
+				};
+
+
+				ListWatermarkResult();
+				explicit ListWatermarkResult(const std::string &payload);
+				~ListWatermarkResult();
+				std::vector<WatermarkInfo> getWatermarkInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<WatermarkInfo> watermarkInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_LISTWATERMARKRESULT_H_

vod/include/alibabacloud/vod/model/RegisterMediaRequest.h

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

vod/include/alibabacloud/vod/model/RegisterMediaResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT RegisterMediaResult : public ServiceResult
+			{
+			public:
+				struct RegisteredMedia
+				{
+					std::string fileURL;
+					std::string mediaId;
+					bool newRegister;
+				};
+
+
+				RegisterMediaResult();
+				explicit RegisterMediaResult(const std::string &payload);
+				~RegisterMediaResult();
+				std::vector<std::string> getFailedFileURLs()const;
+				std::vector<RegisteredMedia> getRegisteredMediaList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> failedFileURLs_;
+				std::vector<RegisteredMedia> registeredMediaList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_REGISTERMEDIARESULT_H_

vod/include/alibabacloud/vod/model/SearchMediaResult.h

@@ -81,11 +81,29 @@ namespace AlibabaCloud
 						std::string tags;
 						std::string audioId;
 					};
+					struct Image
+					{
+						std::string ext;
+						std::string status;
+						std::string description;
+						std::string title;
+						std::string modificationTime;
+						long cateId;
+						std::string cateName;
+						std::string uRL;
+						std::string type;
+						std::string imageId;
+						std::string creationTime;
+						std::string regionId;
+						std::string storageLocation;
+						std::string tags;
+					};
 					std::string mediaId;
 					Video video;
 					std::string creationTime;
 					std::string mediaType;
 					Audio audio;
+					Image image;
 				};
 
 

vod/include/alibabacloud/vod/model/SetDefaultWatermarkRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_
+#define ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT SetDefaultWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetDefaultWatermarkRequest();
+				~SetDefaultWatermarkRequest();
+
+				std::string getWatermarkId()const;
+				void setWatermarkId(const std::string& watermarkId);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string watermarkId_;
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKREQUEST_H_

vod/include/alibabacloud/vod/model/SetDefaultWatermarkResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT SetDefaultWatermarkResult : public ServiceResult
+			{
+			public:
+
+
+				SetDefaultWatermarkResult();
+				explicit SetDefaultWatermarkResult(const std::string &payload);
+				~SetDefaultWatermarkResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_SETDEFAULTWATERMARKRESULT_H_

vod/include/alibabacloud/vod/model/SubmitTranscodeJobsRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getVideoId()const;
 				void setVideoId(const std::string& videoId);
+				std::string getOverrideParams()const;
+				void setOverrideParams(const std::string& overrideParams);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getEncryptConfig()const;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
 				std::string templateGroupId_;
 				std::string resourceOwnerAccount_;
 				std::string videoId_;
+				std::string overrideParams_;
 				long ownerId_;
 				std::string encryptConfig_;
 				std::string accessKeyId_;

vod/include/alibabacloud/vod/model/UpdateWatermarkRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_
+#define ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT UpdateWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateWatermarkRequest();
+				~UpdateWatermarkRequest();
+
+				std::string getWatermarkId()const;
+				void setWatermarkId(const std::string& watermarkId);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getName()const;
+				void setName(const std::string& name);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getWatermarkConfig()const;
+				void setWatermarkConfig(const std::string& watermarkConfig);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string watermarkId_;
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string name_;
+				long ownerId_;
+				std::string watermarkConfig_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKREQUEST_H_

vod/include/alibabacloud/vod/model/UpdateWatermarkResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_
+#define ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vod/VodExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vod
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VOD_EXPORT UpdateWatermarkResult : public ServiceResult
+			{
+			public:
+				struct WatermarkInfo
+				{
+					std::string isDefault;
+					std::string fileUrl;
+					std::string type;
+					std::string watermarkId;
+					std::string creationTime;
+					std::string watermarkConfig;
+					std::string name;
+				};
+
+
+				UpdateWatermarkResult();
+				explicit UpdateWatermarkResult(const std::string &payload);
+				~UpdateWatermarkResult();
+				WatermarkInfo getWatermarkInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				WatermarkInfo watermarkInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VOD_MODEL_UPDATEWATERMARKRESULT_H_

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_;
+}
+