Release GenerateDynamicImage.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-10-13 Version: patch
+- Release GenerateDynamicImage.
+
 2020-10-13 Version: patch
 - Generated 2019-01-01 for `Cassandra`.
 

imageenhan/CMakeLists.txt

@@ -0,0 +1,150 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(imageenhan_public_header 
+	include/alibabacloud/imageenhan/ImageenhanClient.h
+	include/alibabacloud/imageenhan/ImageenhanExport.h )
+
+set(imageenhan_public_header_model 
+	include/alibabacloud/imageenhan/model/AssessCompositionRequest.h
+	include/alibabacloud/imageenhan/model/AssessCompositionResult.h
+	include/alibabacloud/imageenhan/model/AssessExposureRequest.h
+	include/alibabacloud/imageenhan/model/AssessExposureResult.h
+	include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h
+	include/alibabacloud/imageenhan/model/AssessSharpnessResult.h
+	include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h
+	include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h
+	include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h
+	include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h
+	include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h
+	include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h
+	include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h
+	include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h
+	include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h
+	include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.h
+	include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h
+	include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h
+	include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h
+	include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h
+	include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h
+	include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h
+	include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h
+	include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h
+	include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h
+	include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h
+	include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h
+	include/alibabacloud/imageenhan/model/RecolorHDImageResult.h
+	include/alibabacloud/imageenhan/model/RecolorImageRequest.h
+	include/alibabacloud/imageenhan/model/RecolorImageResult.h
+	include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.h
+	include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h
+	include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h
+	include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h )
+
+set(imageenhan_src 
+	src/ImageenhanClient.cc
+	src/model/AssessCompositionRequest.cc
+	src/model/AssessCompositionResult.cc
+	src/model/AssessExposureRequest.cc
+	src/model/AssessExposureResult.cc
+	src/model/AssessSharpnessRequest.cc
+	src/model/AssessSharpnessResult.cc
+	src/model/ChangeImageSizeRequest.cc
+	src/model/ChangeImageSizeResult.cc
+	src/model/EnhanceImageColorRequest.cc
+	src/model/EnhanceImageColorResult.cc
+	src/model/ExtendImageStyleRequest.cc
+	src/model/ExtendImageStyleResult.cc
+	src/model/GenerateDynamicImageRequest.cc
+	src/model/GenerateDynamicImageResult.cc
+	src/model/GetAsyncJobResultRequest.cc
+	src/model/GetAsyncJobResultResult.cc
+	src/model/ImageBlindCharacterWatermarkRequest.cc
+	src/model/ImageBlindCharacterWatermarkResult.cc
+	src/model/ImageBlindPicWatermarkRequest.cc
+	src/model/ImageBlindPicWatermarkResult.cc
+	src/model/ImitatePhotoStyleRequest.cc
+	src/model/ImitatePhotoStyleResult.cc
+	src/model/IntelligentCompositionRequest.cc
+	src/model/IntelligentCompositionResult.cc
+	src/model/MakeSuperResolutionImageRequest.cc
+	src/model/MakeSuperResolutionImageResult.cc
+	src/model/RecolorHDImageRequest.cc
+	src/model/RecolorHDImageResult.cc
+	src/model/RecolorImageRequest.cc
+	src/model/RecolorImageResult.cc
+	src/model/RemoveImageSubtitlesRequest.cc
+	src/model/RemoveImageSubtitlesResult.cc
+	src/model/RemoveImageWatermarkRequest.cc
+	src/model/RemoveImageWatermarkResult.cc )
+
+add_library(imageenhan ${LIB_TYPE}
+	${imageenhan_public_header}
+	${imageenhan_public_header_model}
+	${imageenhan_src})
+
+set_target_properties(imageenhan
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}imageenhan
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(imageenhan
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_IMAGEENHAN_LIBRARY)
+endif()
+
+target_include_directories(imageenhan
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(imageenhan
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(imageenhan
+		jsoncpp)
+	target_include_directories(imageenhan
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(imageenhan
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(imageenhan
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(imageenhan
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(imageenhan
+		jsoncpp)
+endif()
+
+install(FILES ${imageenhan_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageenhan)
+install(FILES ${imageenhan_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/imageenhan/model)
+install(TARGETS imageenhan
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

imageenhan/include/alibabacloud/imageenhan/ImageenhanClient.h

@@ -0,0 +1,182 @@
+/*
+ * 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_IMAGEENHAN_IMAGEENHANCLIENT_H_
+#define ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ImageenhanExport.h"
+#include "model/AssessCompositionRequest.h"
+#include "model/AssessCompositionResult.h"
+#include "model/AssessExposureRequest.h"
+#include "model/AssessExposureResult.h"
+#include "model/AssessSharpnessRequest.h"
+#include "model/AssessSharpnessResult.h"
+#include "model/ChangeImageSizeRequest.h"
+#include "model/ChangeImageSizeResult.h"
+#include "model/EnhanceImageColorRequest.h"
+#include "model/EnhanceImageColorResult.h"
+#include "model/ExtendImageStyleRequest.h"
+#include "model/ExtendImageStyleResult.h"
+#include "model/GenerateDynamicImageRequest.h"
+#include "model/GenerateDynamicImageResult.h"
+#include "model/GetAsyncJobResultRequest.h"
+#include "model/GetAsyncJobResultResult.h"
+#include "model/ImageBlindCharacterWatermarkRequest.h"
+#include "model/ImageBlindCharacterWatermarkResult.h"
+#include "model/ImageBlindPicWatermarkRequest.h"
+#include "model/ImageBlindPicWatermarkResult.h"
+#include "model/ImitatePhotoStyleRequest.h"
+#include "model/ImitatePhotoStyleResult.h"
+#include "model/IntelligentCompositionRequest.h"
+#include "model/IntelligentCompositionResult.h"
+#include "model/MakeSuperResolutionImageRequest.h"
+#include "model/MakeSuperResolutionImageResult.h"
+#include "model/RecolorHDImageRequest.h"
+#include "model/RecolorHDImageResult.h"
+#include "model/RecolorImageRequest.h"
+#include "model/RecolorImageResult.h"
+#include "model/RemoveImageSubtitlesRequest.h"
+#include "model/RemoveImageSubtitlesResult.h"
+#include "model/RemoveImageWatermarkRequest.h"
+#include "model/RemoveImageWatermarkResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageenhanClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AssessCompositionResult> AssessCompositionOutcome;
+			typedef std::future<AssessCompositionOutcome> AssessCompositionOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::AssessCompositionRequest&, const AssessCompositionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessCompositionAsyncHandler;
+			typedef Outcome<Error, Model::AssessExposureResult> AssessExposureOutcome;
+			typedef std::future<AssessExposureOutcome> AssessExposureOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::AssessExposureRequest&, const AssessExposureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessExposureAsyncHandler;
+			typedef Outcome<Error, Model::AssessSharpnessResult> AssessSharpnessOutcome;
+			typedef std::future<AssessSharpnessOutcome> AssessSharpnessOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::AssessSharpnessRequest&, const AssessSharpnessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssessSharpnessAsyncHandler;
+			typedef Outcome<Error, Model::ChangeImageSizeResult> ChangeImageSizeOutcome;
+			typedef std::future<ChangeImageSizeOutcome> ChangeImageSizeOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::ChangeImageSizeRequest&, const ChangeImageSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeImageSizeAsyncHandler;
+			typedef Outcome<Error, Model::EnhanceImageColorResult> EnhanceImageColorOutcome;
+			typedef std::future<EnhanceImageColorOutcome> EnhanceImageColorOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::EnhanceImageColorRequest&, const EnhanceImageColorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnhanceImageColorAsyncHandler;
+			typedef Outcome<Error, Model::ExtendImageStyleResult> ExtendImageStyleOutcome;
+			typedef std::future<ExtendImageStyleOutcome> ExtendImageStyleOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::ExtendImageStyleRequest&, const ExtendImageStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtendImageStyleAsyncHandler;
+			typedef Outcome<Error, Model::GenerateDynamicImageResult> GenerateDynamicImageOutcome;
+			typedef std::future<GenerateDynamicImageOutcome> GenerateDynamicImageOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::GenerateDynamicImageRequest&, const GenerateDynamicImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateDynamicImageAsyncHandler;
+			typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
+			typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
+			typedef Outcome<Error, Model::ImageBlindCharacterWatermarkResult> ImageBlindCharacterWatermarkOutcome;
+			typedef std::future<ImageBlindCharacterWatermarkOutcome> ImageBlindCharacterWatermarkOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::ImageBlindCharacterWatermarkRequest&, const ImageBlindCharacterWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageBlindCharacterWatermarkAsyncHandler;
+			typedef Outcome<Error, Model::ImageBlindPicWatermarkResult> ImageBlindPicWatermarkOutcome;
+			typedef std::future<ImageBlindPicWatermarkOutcome> ImageBlindPicWatermarkOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::ImageBlindPicWatermarkRequest&, const ImageBlindPicWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageBlindPicWatermarkAsyncHandler;
+			typedef Outcome<Error, Model::ImitatePhotoStyleResult> ImitatePhotoStyleOutcome;
+			typedef std::future<ImitatePhotoStyleOutcome> ImitatePhotoStyleOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::ImitatePhotoStyleRequest&, const ImitatePhotoStyleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImitatePhotoStyleAsyncHandler;
+			typedef Outcome<Error, Model::IntelligentCompositionResult> IntelligentCompositionOutcome;
+			typedef std::future<IntelligentCompositionOutcome> IntelligentCompositionOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::IntelligentCompositionRequest&, const IntelligentCompositionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IntelligentCompositionAsyncHandler;
+			typedef Outcome<Error, Model::MakeSuperResolutionImageResult> MakeSuperResolutionImageOutcome;
+			typedef std::future<MakeSuperResolutionImageOutcome> MakeSuperResolutionImageOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::MakeSuperResolutionImageRequest&, const MakeSuperResolutionImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MakeSuperResolutionImageAsyncHandler;
+			typedef Outcome<Error, Model::RecolorHDImageResult> RecolorHDImageOutcome;
+			typedef std::future<RecolorHDImageOutcome> RecolorHDImageOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::RecolorHDImageRequest&, const RecolorHDImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecolorHDImageAsyncHandler;
+			typedef Outcome<Error, Model::RecolorImageResult> RecolorImageOutcome;
+			typedef std::future<RecolorImageOutcome> RecolorImageOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::RecolorImageRequest&, const RecolorImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecolorImageAsyncHandler;
+			typedef Outcome<Error, Model::RemoveImageSubtitlesResult> RemoveImageSubtitlesOutcome;
+			typedef std::future<RemoveImageSubtitlesOutcome> RemoveImageSubtitlesOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::RemoveImageSubtitlesRequest&, const RemoveImageSubtitlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveImageSubtitlesAsyncHandler;
+			typedef Outcome<Error, Model::RemoveImageWatermarkResult> RemoveImageWatermarkOutcome;
+			typedef std::future<RemoveImageWatermarkOutcome> RemoveImageWatermarkOutcomeCallable;
+			typedef std::function<void(const ImageenhanClient*, const Model::RemoveImageWatermarkRequest&, const RemoveImageWatermarkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveImageWatermarkAsyncHandler;
+
+			ImageenhanClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ImageenhanClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ImageenhanClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ImageenhanClient();
+			AssessCompositionOutcome assessComposition(const Model::AssessCompositionRequest &request)const;
+			void assessCompositionAsync(const Model::AssessCompositionRequest& request, const AssessCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssessCompositionOutcomeCallable assessCompositionCallable(const Model::AssessCompositionRequest& request) const;
+			AssessExposureOutcome assessExposure(const Model::AssessExposureRequest &request)const;
+			void assessExposureAsync(const Model::AssessExposureRequest& request, const AssessExposureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssessExposureOutcomeCallable assessExposureCallable(const Model::AssessExposureRequest& request) const;
+			AssessSharpnessOutcome assessSharpness(const Model::AssessSharpnessRequest &request)const;
+			void assessSharpnessAsync(const Model::AssessSharpnessRequest& request, const AssessSharpnessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssessSharpnessOutcomeCallable assessSharpnessCallable(const Model::AssessSharpnessRequest& request) const;
+			ChangeImageSizeOutcome changeImageSize(const Model::ChangeImageSizeRequest &request)const;
+			void changeImageSizeAsync(const Model::ChangeImageSizeRequest& request, const ChangeImageSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ChangeImageSizeOutcomeCallable changeImageSizeCallable(const Model::ChangeImageSizeRequest& request) const;
+			EnhanceImageColorOutcome enhanceImageColor(const Model::EnhanceImageColorRequest &request)const;
+			void enhanceImageColorAsync(const Model::EnhanceImageColorRequest& request, const EnhanceImageColorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnhanceImageColorOutcomeCallable enhanceImageColorCallable(const Model::EnhanceImageColorRequest& request) const;
+			ExtendImageStyleOutcome extendImageStyle(const Model::ExtendImageStyleRequest &request)const;
+			void extendImageStyleAsync(const Model::ExtendImageStyleRequest& request, const ExtendImageStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExtendImageStyleOutcomeCallable extendImageStyleCallable(const Model::ExtendImageStyleRequest& request) const;
+			GenerateDynamicImageOutcome generateDynamicImage(const Model::GenerateDynamicImageRequest &request)const;
+			void generateDynamicImageAsync(const Model::GenerateDynamicImageRequest& request, const GenerateDynamicImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateDynamicImageOutcomeCallable generateDynamicImageCallable(const Model::GenerateDynamicImageRequest& request) const;
+			GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
+			void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
+			ImageBlindCharacterWatermarkOutcome imageBlindCharacterWatermark(const Model::ImageBlindCharacterWatermarkRequest &request)const;
+			void imageBlindCharacterWatermarkAsync(const Model::ImageBlindCharacterWatermarkRequest& request, const ImageBlindCharacterWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImageBlindCharacterWatermarkOutcomeCallable imageBlindCharacterWatermarkCallable(const Model::ImageBlindCharacterWatermarkRequest& request) const;
+			ImageBlindPicWatermarkOutcome imageBlindPicWatermark(const Model::ImageBlindPicWatermarkRequest &request)const;
+			void imageBlindPicWatermarkAsync(const Model::ImageBlindPicWatermarkRequest& request, const ImageBlindPicWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImageBlindPicWatermarkOutcomeCallable imageBlindPicWatermarkCallable(const Model::ImageBlindPicWatermarkRequest& request) const;
+			ImitatePhotoStyleOutcome imitatePhotoStyle(const Model::ImitatePhotoStyleRequest &request)const;
+			void imitatePhotoStyleAsync(const Model::ImitatePhotoStyleRequest& request, const ImitatePhotoStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImitatePhotoStyleOutcomeCallable imitatePhotoStyleCallable(const Model::ImitatePhotoStyleRequest& request) const;
+			IntelligentCompositionOutcome intelligentComposition(const Model::IntelligentCompositionRequest &request)const;
+			void intelligentCompositionAsync(const Model::IntelligentCompositionRequest& request, const IntelligentCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			IntelligentCompositionOutcomeCallable intelligentCompositionCallable(const Model::IntelligentCompositionRequest& request) const;
+			MakeSuperResolutionImageOutcome makeSuperResolutionImage(const Model::MakeSuperResolutionImageRequest &request)const;
+			void makeSuperResolutionImageAsync(const Model::MakeSuperResolutionImageRequest& request, const MakeSuperResolutionImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MakeSuperResolutionImageOutcomeCallable makeSuperResolutionImageCallable(const Model::MakeSuperResolutionImageRequest& request) const;
+			RecolorHDImageOutcome recolorHDImage(const Model::RecolorHDImageRequest &request)const;
+			void recolorHDImageAsync(const Model::RecolorHDImageRequest& request, const RecolorHDImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecolorHDImageOutcomeCallable recolorHDImageCallable(const Model::RecolorHDImageRequest& request) const;
+			RecolorImageOutcome recolorImage(const Model::RecolorImageRequest &request)const;
+			void recolorImageAsync(const Model::RecolorImageRequest& request, const RecolorImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecolorImageOutcomeCallable recolorImageCallable(const Model::RecolorImageRequest& request) const;
+			RemoveImageSubtitlesOutcome removeImageSubtitles(const Model::RemoveImageSubtitlesRequest &request)const;
+			void removeImageSubtitlesAsync(const Model::RemoveImageSubtitlesRequest& request, const RemoveImageSubtitlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveImageSubtitlesOutcomeCallable removeImageSubtitlesCallable(const Model::RemoveImageSubtitlesRequest& request) const;
+			RemoveImageWatermarkOutcome removeImageWatermark(const Model::RemoveImageWatermarkRequest &request)const;
+			void removeImageWatermarkAsync(const Model::RemoveImageWatermarkRequest& request, const RemoveImageWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveImageWatermarkOutcomeCallable removeImageWatermarkCallable(const Model::RemoveImageWatermarkRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANCLIENT_H_

imageenhan/include/alibabacloud/imageenhan/ImageenhanExport.h

@@ -0,0 +1,32 @@
+/*
+ * 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_IMAGEENHAN_IMAGEENHANEXPORT_H_
+#define ALIBABACLOUD_IMAGEENHAN_IMAGEENHANEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_IMAGEENHAN_LIBRARY)
+#		define ALIBABACLOUD_IMAGEENHAN_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_IMAGEENHAN_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_IMAGEENHAN_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_IMAGEENHAN_IMAGEENHANEXPORT_H_

imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionRequest.h

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

imageenhan/include/alibabacloud/imageenhan/model/AssessCompositionResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessCompositionResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					float score;
+				};
+
+
+				AssessCompositionResult();
+				explicit AssessCompositionResult(const std::string &payload);
+				~AssessCompositionResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSCOMPOSITIONRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/AssessExposureRequest.h

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

imageenhan/include/alibabacloud/imageenhan/model/AssessExposureResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessExposureResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					float exposure;
+				};
+
+
+				AssessExposureResult();
+				explicit AssessExposureResult(const std::string &payload);
+				~AssessExposureResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSEXPOSURERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessRequest.h

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

imageenhan/include/alibabacloud/imageenhan/model/AssessSharpnessResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT AssessSharpnessResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					float sharpness;
+				};
+
+
+				AssessSharpnessResult();
+				explicit AssessSharpnessResult(const std::string &payload);
+				~AssessSharpnessResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ASSESSSHARPNESSRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ChangeImageSizeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ChangeImageSizeRequest();
+				~ChangeImageSizeRequest();
+
+				std::string getUrl()const;
+				void setUrl(const std::string& url);
+				int getWidth()const;
+				void setWidth(int width);
+				int getHeight()const;
+				void setHeight(int height);
+
+            private:
+				std::string url_;
+				int width_;
+				int height_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_CHANGEIMAGESIZEREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/ChangeImageSizeResult.h

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

imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnhanceImageColorRequest();
+				~EnhanceImageColorRequest();
+
+				std::string getMode()const;
+				void setMode(const std::string& mode);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+				std::string getOutputFormat()const;
+				void setOutputFormat(const std::string& outputFormat);
+
+            private:
+				std::string mode_;
+				std::string imageURL_;
+				std::string outputFormat_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/EnhanceImageColorResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT EnhanceImageColorResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageURL;
+				};
+
+
+				EnhanceImageColorResult();
+				explicit EnhanceImageColorResult(const std::string &payload);
+				~EnhanceImageColorResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_ENHANCEIMAGECOLORRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtendImageStyleRequest();
+				~ExtendImageStyleRequest();
+
+				std::string getMajorUrl()const;
+				void setMajorUrl(const std::string& majorUrl);
+				std::string getStyleUrl()const;
+				void setStyleUrl(const std::string& styleUrl);
+
+            private:
+				std::string majorUrl_;
+				std::string styleUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLEREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/ExtendImageStyleResult.h

@@ -0,0 +1,56 @@
+/*
+ * 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_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ExtendImageStyleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string url;
+					std::string majorUrl;
+				};
+
+
+				ExtendImageStyleResult();
+				explicit ExtendImageStyleResult(const std::string &payload);
+				~ExtendImageStyleResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_EXTENDIMAGESTYLERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				GenerateDynamicImageRequest();
+				~GenerateDynamicImageRequest();
+
+				std::string getUrl()const;
+				void setUrl(const std::string& url);
+				std::string getOperation()const;
+				void setOperation(const std::string& operation);
+
+            private:
+				std::string url_;
+				std::string operation_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGEREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/GenerateDynamicImageResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT GenerateDynamicImageResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string url;
+				};
+
+
+				GenerateDynamicImageResult();
+				explicit GenerateDynamicImageResult(const std::string &payload);
+				~GenerateDynamicImageResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GENERATEDYNAMICIMAGERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAsyncJobResultRequest();
+				~GetAsyncJobResultRequest();
+
+				bool getAsync()const;
+				void setAsync(bool async);
+				std::string getJobId()const;
+				void setJobId(const std::string& jobId);
+
+            private:
+				bool async_;
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/GetAsyncJobResultResult.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_IMAGEENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT GetAsyncJobResultResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string status;
+					std::string errorCode;
+					std::string errorMessage;
+					std::string jobId;
+					std::string result;
+				};
+
+
+				GetAsyncJobResultResult();
+				explicit GetAsyncJobResultResult(const std::string &payload);
+				~GetAsyncJobResultResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindCharacterWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				ImageBlindCharacterWatermarkRequest();
+				~ImageBlindCharacterWatermarkRequest();
+
+				std::string getWatermarkImageURL()const;
+				void setWatermarkImageURL(const std::string& watermarkImageURL);
+				int getQualityFactor()const;
+				void setQualityFactor(int qualityFactor);
+				std::string getFunctionType()const;
+				void setFunctionType(const std::string& functionType);
+				std::string getOutputFileType()const;
+				void setOutputFileType(const std::string& outputFileType);
+				std::string getOriginImageURL()const;
+				void setOriginImageURL(const std::string& originImageURL);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string watermarkImageURL_;
+				int qualityFactor_;
+				std::string functionType_;
+				std::string outputFileType_;
+				std::string originImageURL_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/ImageBlindCharacterWatermarkResult.h

@@ -0,0 +1,56 @@
+/*
+ * 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_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindCharacterWatermarkResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string textImageURL;
+					std::string watermarkImageURL;
+				};
+
+
+				ImageBlindCharacterWatermarkResult();
+				explicit ImageBlindCharacterWatermarkResult(const std::string &payload);
+				~ImageBlindCharacterWatermarkResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDCHARACTERWATERMARKRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindPicWatermarkRequest : public RpcServiceRequest
+			{
+
+			public:
+				ImageBlindPicWatermarkRequest();
+				~ImageBlindPicWatermarkRequest();
+
+				std::string getWatermarkImageURL()const;
+				void setWatermarkImageURL(const std::string& watermarkImageURL);
+				int getQualityFactor()const;
+				void setQualityFactor(int qualityFactor);
+				std::string getFunctionType()const;
+				void setFunctionType(const std::string& functionType);
+				std::string getLogoURL()const;
+				void setLogoURL(const std::string& logoURL);
+				std::string getOutputFileType()const;
+				void setOutputFileType(const std::string& outputFileType);
+				std::string getOriginImageURL()const;
+				void setOriginImageURL(const std::string& originImageURL);
+
+            private:
+				std::string watermarkImageURL_;
+				int qualityFactor_;
+				std::string functionType_;
+				std::string logoURL_;
+				std::string outputFileType_;
+				std::string originImageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/ImageBlindPicWatermarkResult.h

@@ -0,0 +1,56 @@
+/*
+ * 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_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ImageBlindPicWatermarkResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string watermarkImageURL;
+					std::string logoURL;
+				};
+
+
+				ImageBlindPicWatermarkResult();
+				explicit ImageBlindPicWatermarkResult(const std::string &payload);
+				~ImageBlindPicWatermarkResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMAGEBLINDPICWATERMARKRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ImitatePhotoStyleRequest : public RpcServiceRequest
+			{
+
+			public:
+				ImitatePhotoStyleRequest();
+				~ImitatePhotoStyleRequest();
+
+				std::string getStyleUrl()const;
+				void setStyleUrl(const std::string& styleUrl);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string styleUrl_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLEREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/ImitatePhotoStyleResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT ImitatePhotoStyleResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageURL;
+				};
+
+
+				ImitatePhotoStyleResult();
+				explicit ImitatePhotoStyleResult(const std::string &payload);
+				~ImitatePhotoStyleResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_IMITATEPHOTOSTYLERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT IntelligentCompositionRequest : public RpcServiceRequest
+			{
+
+			public:
+				IntelligentCompositionRequest();
+				~IntelligentCompositionRequest();
+
+				int getNumBoxes()const;
+				void setNumBoxes(int numBoxes);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				int numBoxes_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_INTELLIGENTCOMPOSITIONREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/IntelligentCompositionResult.h

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

imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageRequest.h

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

imageenhan/include/alibabacloud/imageenhan/model/MakeSuperResolutionImageResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT MakeSuperResolutionImageResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string url;
+				};
+
+
+				MakeSuperResolutionImageResult();
+				explicit MakeSuperResolutionImageResult(const std::string &payload);
+				~MakeSuperResolutionImageResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_MAKESUPERRESOLUTIONIMAGERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageRequest : public RpcServiceRequest
+			{
+			public:
+				struct ColorTemplate
+				{
+					std::string color;
+				};
+
+			public:
+				RecolorHDImageRequest();
+				~RecolorHDImageRequest();
+
+				std::vector<ColorTemplate> getColorTemplate()const;
+				void setColorTemplate(const std::vector<ColorTemplate>& colorTemplate);
+				std::string getDegree()const;
+				void setDegree(const std::string& degree);
+				std::string getUrl()const;
+				void setUrl(const std::string& url);
+				std::string getMode()const;
+				void setMode(const std::string& mode);
+				bool getAsync()const;
+				void setAsync(bool async);
+				int getColorCount()const;
+				void setColorCount(int colorCount);
+				std::string getRefUrl()const;
+				void setRefUrl(const std::string& refUrl);
+
+            private:
+				std::vector<ColorTemplate> colorTemplate_;
+				std::string degree_;
+				std::string url_;
+				std::string mode_;
+				bool async_;
+				int colorCount_;
+				std::string refUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGEREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/RecolorHDImageResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorHDImageResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::vector<std::string> imageList;
+				};
+
+
+				RecolorHDImageResult();
+				explicit RecolorHDImageResult(const std::string &payload);
+				~RecolorHDImageResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORHDIMAGERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/RecolorImageRequest.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageRequest : public RpcServiceRequest
+			{
+			public:
+				struct ColorTemplate
+				{
+					std::string color;
+				};
+
+			public:
+				RecolorImageRequest();
+				~RecolorImageRequest();
+
+				std::vector<ColorTemplate> getColorTemplate()const;
+				void setColorTemplate(const std::vector<ColorTemplate>& colorTemplate);
+				std::string getUrl()const;
+				void setUrl(const std::string& url);
+				std::string getMode()const;
+				void setMode(const std::string& mode);
+				int getColorCount()const;
+				void setColorCount(int colorCount);
+				std::string getRefUrl()const;
+				void setRefUrl(const std::string& refUrl);
+
+            private:
+				std::vector<ColorTemplate> colorTemplate_;
+				std::string url_;
+				std::string mode_;
+				int colorCount_;
+				std::string refUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGEREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/RecolorImageResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RecolorImageResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::vector<std::string> imageList;
+				};
+
+
+				RecolorImageResult();
+				explicit RecolorImageResult(const std::string &payload);
+				~RecolorImageResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_RECOLORIMAGERESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesRequest.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_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageSubtitlesRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemoveImageSubtitlesRequest();
+				~RemoveImageSubtitlesRequest();
+
+				float getBH()const;
+				void setBH(float bH);
+				float getBW()const;
+				void setBW(float bW);
+				float getBX()const;
+				void setBX(float bX);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+				float getBY()const;
+				void setBY(float bY);
+
+            private:
+				float bH_;
+				float bW_;
+				float bX_;
+				std::string imageURL_;
+				float bY_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESREQUEST_H_

imageenhan/include/alibabacloud/imageenhan/model/RemoveImageSubtitlesResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageSubtitlesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageURL;
+				};
+
+
+				RemoveImageSubtitlesResult();
+				explicit RemoveImageSubtitlesResult(const std::string &payload);
+				~RemoveImageSubtitlesResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGESUBTITLESRESULT_H_

imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkRequest.h

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

imageenhan/include/alibabacloud/imageenhan/model/RemoveImageWatermarkResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_
+#define ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/imageenhan/ImageenhanExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageenhan
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEENHAN_EXPORT RemoveImageWatermarkResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string imageURL;
+				};
+
+
+				RemoveImageWatermarkResult();
+				explicit RemoveImageWatermarkResult(const std::string &payload);
+				~RemoveImageWatermarkResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEENHAN_MODEL_REMOVEIMAGEWATERMARKRESULT_H_

imageenhan/src/ImageenhanClient.cc

@@ -0,0 +1,665 @@
+/*
+ * 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/imageenhan/ImageenhanClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "imageenhan";
+}
+
+ImageenhanClient::ImageenhanClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageenhan");
+}
+
+ImageenhanClient::ImageenhanClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageenhan");
+}
+
+ImageenhanClient::ImageenhanClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "imageenhan");
+}
+
+ImageenhanClient::~ImageenhanClient()
+{}
+
+ImageenhanClient::AssessCompositionOutcome ImageenhanClient::assessComposition(const AssessCompositionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AssessCompositionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AssessCompositionOutcome(AssessCompositionResult(outcome.result()));
+	else
+		return AssessCompositionOutcome(outcome.error());
+}
+
+void ImageenhanClient::assessCompositionAsync(const AssessCompositionRequest& request, const AssessCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, assessComposition(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::AssessCompositionOutcomeCallable ImageenhanClient::assessCompositionCallable(const AssessCompositionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AssessCompositionOutcome()>>(
+			[this, request]()
+			{
+			return this->assessComposition(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::AssessExposureOutcome ImageenhanClient::assessExposure(const AssessExposureRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AssessExposureOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AssessExposureOutcome(AssessExposureResult(outcome.result()));
+	else
+		return AssessExposureOutcome(outcome.error());
+}
+
+void ImageenhanClient::assessExposureAsync(const AssessExposureRequest& request, const AssessExposureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, assessExposure(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::AssessExposureOutcomeCallable ImageenhanClient::assessExposureCallable(const AssessExposureRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AssessExposureOutcome()>>(
+			[this, request]()
+			{
+			return this->assessExposure(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::AssessSharpnessOutcome ImageenhanClient::assessSharpness(const AssessSharpnessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AssessSharpnessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AssessSharpnessOutcome(AssessSharpnessResult(outcome.result()));
+	else
+		return AssessSharpnessOutcome(outcome.error());
+}
+
+void ImageenhanClient::assessSharpnessAsync(const AssessSharpnessRequest& request, const AssessSharpnessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, assessSharpness(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::AssessSharpnessOutcomeCallable ImageenhanClient::assessSharpnessCallable(const AssessSharpnessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AssessSharpnessOutcome()>>(
+			[this, request]()
+			{
+			return this->assessSharpness(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::ChangeImageSizeOutcome ImageenhanClient::changeImageSize(const ChangeImageSizeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ChangeImageSizeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ChangeImageSizeOutcome(ChangeImageSizeResult(outcome.result()));
+	else
+		return ChangeImageSizeOutcome(outcome.error());
+}
+
+void ImageenhanClient::changeImageSizeAsync(const ChangeImageSizeRequest& request, const ChangeImageSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, changeImageSize(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::ChangeImageSizeOutcomeCallable ImageenhanClient::changeImageSizeCallable(const ChangeImageSizeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ChangeImageSizeOutcome()>>(
+			[this, request]()
+			{
+			return this->changeImageSize(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::EnhanceImageColorOutcome ImageenhanClient::enhanceImageColor(const EnhanceImageColorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnhanceImageColorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnhanceImageColorOutcome(EnhanceImageColorResult(outcome.result()));
+	else
+		return EnhanceImageColorOutcome(outcome.error());
+}
+
+void ImageenhanClient::enhanceImageColorAsync(const EnhanceImageColorRequest& request, const EnhanceImageColorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enhanceImageColor(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::EnhanceImageColorOutcomeCallable ImageenhanClient::enhanceImageColorCallable(const EnhanceImageColorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnhanceImageColorOutcome()>>(
+			[this, request]()
+			{
+			return this->enhanceImageColor(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::ExtendImageStyleOutcome ImageenhanClient::extendImageStyle(const ExtendImageStyleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtendImageStyleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtendImageStyleOutcome(ExtendImageStyleResult(outcome.result()));
+	else
+		return ExtendImageStyleOutcome(outcome.error());
+}
+
+void ImageenhanClient::extendImageStyleAsync(const ExtendImageStyleRequest& request, const ExtendImageStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extendImageStyle(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::ExtendImageStyleOutcomeCallable ImageenhanClient::extendImageStyleCallable(const ExtendImageStyleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtendImageStyleOutcome()>>(
+			[this, request]()
+			{
+			return this->extendImageStyle(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::GenerateDynamicImageOutcome ImageenhanClient::generateDynamicImage(const GenerateDynamicImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenerateDynamicImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenerateDynamicImageOutcome(GenerateDynamicImageResult(outcome.result()));
+	else
+		return GenerateDynamicImageOutcome(outcome.error());
+}
+
+void ImageenhanClient::generateDynamicImageAsync(const GenerateDynamicImageRequest& request, const GenerateDynamicImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, generateDynamicImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::GenerateDynamicImageOutcomeCallable ImageenhanClient::generateDynamicImageCallable(const GenerateDynamicImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenerateDynamicImageOutcome()>>(
+			[this, request]()
+			{
+			return this->generateDynamicImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::GetAsyncJobResultOutcome ImageenhanClient::getAsyncJobResult(const GetAsyncJobResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAsyncJobResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAsyncJobResultOutcome(GetAsyncJobResultResult(outcome.result()));
+	else
+		return GetAsyncJobResultOutcome(outcome.error());
+}
+
+void ImageenhanClient::getAsyncJobResultAsync(const GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAsyncJobResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::GetAsyncJobResultOutcomeCallable ImageenhanClient::getAsyncJobResultCallable(const GetAsyncJobResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAsyncJobResultOutcome()>>(
+			[this, request]()
+			{
+			return this->getAsyncJobResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::ImageBlindCharacterWatermarkOutcome ImageenhanClient::imageBlindCharacterWatermark(const ImageBlindCharacterWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImageBlindCharacterWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImageBlindCharacterWatermarkOutcome(ImageBlindCharacterWatermarkResult(outcome.result()));
+	else
+		return ImageBlindCharacterWatermarkOutcome(outcome.error());
+}
+
+void ImageenhanClient::imageBlindCharacterWatermarkAsync(const ImageBlindCharacterWatermarkRequest& request, const ImageBlindCharacterWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imageBlindCharacterWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::ImageBlindCharacterWatermarkOutcomeCallable ImageenhanClient::imageBlindCharacterWatermarkCallable(const ImageBlindCharacterWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImageBlindCharacterWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->imageBlindCharacterWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::ImageBlindPicWatermarkOutcome ImageenhanClient::imageBlindPicWatermark(const ImageBlindPicWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImageBlindPicWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImageBlindPicWatermarkOutcome(ImageBlindPicWatermarkResult(outcome.result()));
+	else
+		return ImageBlindPicWatermarkOutcome(outcome.error());
+}
+
+void ImageenhanClient::imageBlindPicWatermarkAsync(const ImageBlindPicWatermarkRequest& request, const ImageBlindPicWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imageBlindPicWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::ImageBlindPicWatermarkOutcomeCallable ImageenhanClient::imageBlindPicWatermarkCallable(const ImageBlindPicWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImageBlindPicWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->imageBlindPicWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::ImitatePhotoStyleOutcome ImageenhanClient::imitatePhotoStyle(const ImitatePhotoStyleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImitatePhotoStyleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImitatePhotoStyleOutcome(ImitatePhotoStyleResult(outcome.result()));
+	else
+		return ImitatePhotoStyleOutcome(outcome.error());
+}
+
+void ImageenhanClient::imitatePhotoStyleAsync(const ImitatePhotoStyleRequest& request, const ImitatePhotoStyleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imitatePhotoStyle(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::ImitatePhotoStyleOutcomeCallable ImageenhanClient::imitatePhotoStyleCallable(const ImitatePhotoStyleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImitatePhotoStyleOutcome()>>(
+			[this, request]()
+			{
+			return this->imitatePhotoStyle(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::IntelligentCompositionOutcome ImageenhanClient::intelligentComposition(const IntelligentCompositionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return IntelligentCompositionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return IntelligentCompositionOutcome(IntelligentCompositionResult(outcome.result()));
+	else
+		return IntelligentCompositionOutcome(outcome.error());
+}
+
+void ImageenhanClient::intelligentCompositionAsync(const IntelligentCompositionRequest& request, const IntelligentCompositionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, intelligentComposition(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::IntelligentCompositionOutcomeCallable ImageenhanClient::intelligentCompositionCallable(const IntelligentCompositionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<IntelligentCompositionOutcome()>>(
+			[this, request]()
+			{
+			return this->intelligentComposition(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::MakeSuperResolutionImageOutcome ImageenhanClient::makeSuperResolutionImage(const MakeSuperResolutionImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MakeSuperResolutionImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MakeSuperResolutionImageOutcome(MakeSuperResolutionImageResult(outcome.result()));
+	else
+		return MakeSuperResolutionImageOutcome(outcome.error());
+}
+
+void ImageenhanClient::makeSuperResolutionImageAsync(const MakeSuperResolutionImageRequest& request, const MakeSuperResolutionImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, makeSuperResolutionImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::MakeSuperResolutionImageOutcomeCallable ImageenhanClient::makeSuperResolutionImageCallable(const MakeSuperResolutionImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MakeSuperResolutionImageOutcome()>>(
+			[this, request]()
+			{
+			return this->makeSuperResolutionImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::RecolorHDImageOutcome ImageenhanClient::recolorHDImage(const RecolorHDImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecolorHDImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecolorHDImageOutcome(RecolorHDImageResult(outcome.result()));
+	else
+		return RecolorHDImageOutcome(outcome.error());
+}
+
+void ImageenhanClient::recolorHDImageAsync(const RecolorHDImageRequest& request, const RecolorHDImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recolorHDImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::RecolorHDImageOutcomeCallable ImageenhanClient::recolorHDImageCallable(const RecolorHDImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecolorHDImageOutcome()>>(
+			[this, request]()
+			{
+			return this->recolorHDImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::RecolorImageOutcome ImageenhanClient::recolorImage(const RecolorImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecolorImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecolorImageOutcome(RecolorImageResult(outcome.result()));
+	else
+		return RecolorImageOutcome(outcome.error());
+}
+
+void ImageenhanClient::recolorImageAsync(const RecolorImageRequest& request, const RecolorImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recolorImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::RecolorImageOutcomeCallable ImageenhanClient::recolorImageCallable(const RecolorImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecolorImageOutcome()>>(
+			[this, request]()
+			{
+			return this->recolorImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::RemoveImageSubtitlesOutcome ImageenhanClient::removeImageSubtitles(const RemoveImageSubtitlesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveImageSubtitlesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveImageSubtitlesOutcome(RemoveImageSubtitlesResult(outcome.result()));
+	else
+		return RemoveImageSubtitlesOutcome(outcome.error());
+}
+
+void ImageenhanClient::removeImageSubtitlesAsync(const RemoveImageSubtitlesRequest& request, const RemoveImageSubtitlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeImageSubtitles(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::RemoveImageSubtitlesOutcomeCallable ImageenhanClient::removeImageSubtitlesCallable(const RemoveImageSubtitlesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveImageSubtitlesOutcome()>>(
+			[this, request]()
+			{
+			return this->removeImageSubtitles(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ImageenhanClient::RemoveImageWatermarkOutcome ImageenhanClient::removeImageWatermark(const RemoveImageWatermarkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveImageWatermarkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveImageWatermarkOutcome(RemoveImageWatermarkResult(outcome.result()));
+	else
+		return RemoveImageWatermarkOutcome(outcome.error());
+}
+
+void ImageenhanClient::removeImageWatermarkAsync(const RemoveImageWatermarkRequest& request, const RemoveImageWatermarkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeImageWatermark(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ImageenhanClient::RemoveImageWatermarkOutcomeCallable ImageenhanClient::removeImageWatermarkCallable(const RemoveImageWatermarkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveImageWatermarkOutcome()>>(
+			[this, request]()
+			{
+			return this->removeImageWatermark(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

imageenhan/src/model/AssessCompositionRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/imageenhan/model/AssessCompositionRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::AssessCompositionRequest;
+
+AssessCompositionRequest::AssessCompositionRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "AssessComposition")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AssessCompositionRequest::~AssessCompositionRequest()
+{}
+
+std::string AssessCompositionRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void AssessCompositionRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

imageenhan/src/model/AssessCompositionResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/AssessCompositionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+AssessCompositionResult::AssessCompositionResult() :
+	ServiceResult()
+{}
+
+AssessCompositionResult::AssessCompositionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AssessCompositionResult::~AssessCompositionResult()
+{}
+
+void AssessCompositionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Score"].isNull())
+		data_.score = std::stof(dataNode["Score"].asString());
+
+}
+
+AssessCompositionResult::Data AssessCompositionResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/AssessExposureRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/imageenhan/model/AssessExposureRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::AssessExposureRequest;
+
+AssessExposureRequest::AssessExposureRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "AssessExposure")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AssessExposureRequest::~AssessExposureRequest()
+{}
+
+std::string AssessExposureRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void AssessExposureRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

imageenhan/src/model/AssessExposureResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/AssessExposureResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+AssessExposureResult::AssessExposureResult() :
+	ServiceResult()
+{}
+
+AssessExposureResult::AssessExposureResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AssessExposureResult::~AssessExposureResult()
+{}
+
+void AssessExposureResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Exposure"].isNull())
+		data_.exposure = std::stof(dataNode["Exposure"].asString());
+
+}
+
+AssessExposureResult::Data AssessExposureResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/AssessSharpnessRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/imageenhan/model/AssessSharpnessRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::AssessSharpnessRequest;
+
+AssessSharpnessRequest::AssessSharpnessRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "AssessSharpness")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AssessSharpnessRequest::~AssessSharpnessRequest()
+{}
+
+std::string AssessSharpnessRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void AssessSharpnessRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

imageenhan/src/model/AssessSharpnessResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/AssessSharpnessResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+AssessSharpnessResult::AssessSharpnessResult() :
+	ServiceResult()
+{}
+
+AssessSharpnessResult::AssessSharpnessResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AssessSharpnessResult::~AssessSharpnessResult()
+{}
+
+void AssessSharpnessResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Sharpness"].isNull())
+		data_.sharpness = std::stof(dataNode["Sharpness"].asString());
+
+}
+
+AssessSharpnessResult::Data AssessSharpnessResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/ChangeImageSizeRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/ChangeImageSizeRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::ChangeImageSizeRequest;
+
+ChangeImageSizeRequest::ChangeImageSizeRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "ChangeImageSize")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ChangeImageSizeRequest::~ChangeImageSizeRequest()
+{}
+
+std::string ChangeImageSizeRequest::getUrl()const
+{
+	return url_;
+}
+
+void ChangeImageSizeRequest::setUrl(const std::string& url)
+{
+	url_ = url;
+	setBodyParameter("Url", url);
+}
+
+int ChangeImageSizeRequest::getWidth()const
+{
+	return width_;
+}
+
+void ChangeImageSizeRequest::setWidth(int width)
+{
+	width_ = width;
+	setBodyParameter("Width", std::to_string(width));
+}
+
+int ChangeImageSizeRequest::getHeight()const
+{
+	return height_;
+}
+
+void ChangeImageSizeRequest::setHeight(int height)
+{
+	height_ = height;
+	setBodyParameter("Height", std::to_string(height));
+}
+

imageenhan/src/model/ChangeImageSizeResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/imageenhan/model/ChangeImageSizeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+ChangeImageSizeResult::ChangeImageSizeResult() :
+	ServiceResult()
+{}
+
+ChangeImageSizeResult::ChangeImageSizeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ChangeImageSizeResult::~ChangeImageSizeResult()
+{}
+
+void ChangeImageSizeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Url"].isNull())
+		data_.url = dataNode["Url"].asString();
+	auto retainLocationNode = dataNode["RetainLocation"];
+	if(!retainLocationNode["X"].isNull())
+		data_.retainLocation.x = std::stoi(retainLocationNode["X"].asString());
+	if(!retainLocationNode["Y"].isNull())
+		data_.retainLocation.y = std::stoi(retainLocationNode["Y"].asString());
+	if(!retainLocationNode["Width"].isNull())
+		data_.retainLocation.width = std::stoi(retainLocationNode["Width"].asString());
+	if(!retainLocationNode["Height"].isNull())
+		data_.retainLocation.height = std::stoi(retainLocationNode["Height"].asString());
+
+}
+
+ChangeImageSizeResult::Data ChangeImageSizeResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/EnhanceImageColorRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/EnhanceImageColorRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::EnhanceImageColorRequest;
+
+EnhanceImageColorRequest::EnhanceImageColorRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "EnhanceImageColor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnhanceImageColorRequest::~EnhanceImageColorRequest()
+{}
+
+std::string EnhanceImageColorRequest::getMode()const
+{
+	return mode_;
+}
+
+void EnhanceImageColorRequest::setMode(const std::string& mode)
+{
+	mode_ = mode;
+	setBodyParameter("Mode", mode);
+}
+
+std::string EnhanceImageColorRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void EnhanceImageColorRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+
+std::string EnhanceImageColorRequest::getOutputFormat()const
+{
+	return outputFormat_;
+}
+
+void EnhanceImageColorRequest::setOutputFormat(const std::string& outputFormat)
+{
+	outputFormat_ = outputFormat;
+	setBodyParameter("OutputFormat", outputFormat);
+}
+

imageenhan/src/model/EnhanceImageColorResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/EnhanceImageColorResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+EnhanceImageColorResult::EnhanceImageColorResult() :
+	ServiceResult()
+{}
+
+EnhanceImageColorResult::EnhanceImageColorResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnhanceImageColorResult::~EnhanceImageColorResult()
+{}
+
+void EnhanceImageColorResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ImageURL"].isNull())
+		data_.imageURL = dataNode["ImageURL"].asString();
+
+}
+
+EnhanceImageColorResult::Data EnhanceImageColorResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/ExtendImageStyleRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/ExtendImageStyleRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::ExtendImageStyleRequest;
+
+ExtendImageStyleRequest::ExtendImageStyleRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "ExtendImageStyle")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ExtendImageStyleRequest::~ExtendImageStyleRequest()
+{}
+
+std::string ExtendImageStyleRequest::getMajorUrl()const
+{
+	return majorUrl_;
+}
+
+void ExtendImageStyleRequest::setMajorUrl(const std::string& majorUrl)
+{
+	majorUrl_ = majorUrl;
+	setBodyParameter("MajorUrl", majorUrl);
+}
+
+std::string ExtendImageStyleRequest::getStyleUrl()const
+{
+	return styleUrl_;
+}
+
+void ExtendImageStyleRequest::setStyleUrl(const std::string& styleUrl)
+{
+	styleUrl_ = styleUrl;
+	setBodyParameter("StyleUrl", styleUrl);
+}
+

imageenhan/src/model/ExtendImageStyleResult.cc

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

imageenhan/src/model/GenerateDynamicImageRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/GenerateDynamicImageRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::GenerateDynamicImageRequest;
+
+GenerateDynamicImageRequest::GenerateDynamicImageRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "GenerateDynamicImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GenerateDynamicImageRequest::~GenerateDynamicImageRequest()
+{}
+
+std::string GenerateDynamicImageRequest::getUrl()const
+{
+	return url_;
+}
+
+void GenerateDynamicImageRequest::setUrl(const std::string& url)
+{
+	url_ = url;
+	setBodyParameter("Url", url);
+}
+
+std::string GenerateDynamicImageRequest::getOperation()const
+{
+	return operation_;
+}
+
+void GenerateDynamicImageRequest::setOperation(const std::string& operation)
+{
+	operation_ = operation;
+	setBodyParameter("Operation", operation);
+}
+

imageenhan/src/model/GenerateDynamicImageResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/GenerateDynamicImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+GenerateDynamicImageResult::GenerateDynamicImageResult() :
+	ServiceResult()
+{}
+
+GenerateDynamicImageResult::GenerateDynamicImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GenerateDynamicImageResult::~GenerateDynamicImageResult()
+{}
+
+void GenerateDynamicImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Url"].isNull())
+		data_.url = dataNode["Url"].asString();
+
+}
+
+GenerateDynamicImageResult::Data GenerateDynamicImageResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/GetAsyncJobResultRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/GetAsyncJobResultRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::GetAsyncJobResultRequest;
+
+GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "GetAsyncJobResult")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
+{}
+
+bool GetAsyncJobResultRequest::getAsync()const
+{
+	return async_;
+}
+
+void GetAsyncJobResultRequest::setAsync(bool async)
+{
+	async_ = async;
+	setBodyParameter("Async", async ? "true" : "false");
+}
+
+std::string GetAsyncJobResultRequest::getJobId()const
+{
+	return jobId_;
+}
+
+void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
+{
+	jobId_ = jobId;
+	setBodyParameter("JobId", jobId);
+}
+

imageenhan/src/model/GetAsyncJobResultResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/imageenhan/model/GetAsyncJobResultResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+GetAsyncJobResultResult::GetAsyncJobResultResult() :
+	ServiceResult()
+{}
+
+GetAsyncJobResultResult::GetAsyncJobResultResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAsyncJobResultResult::~GetAsyncJobResultResult()
+{}
+
+void GetAsyncJobResultResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["JobId"].isNull())
+		data_.jobId = dataNode["JobId"].asString();
+	if(!dataNode["Status"].isNull())
+		data_.status = dataNode["Status"].asString();
+	if(!dataNode["Result"].isNull())
+		data_.result = dataNode["Result"].asString();
+	if(!dataNode["ErrorCode"].isNull())
+		data_.errorCode = dataNode["ErrorCode"].asString();
+	if(!dataNode["ErrorMessage"].isNull())
+		data_.errorMessage = dataNode["ErrorMessage"].asString();
+
+}
+
+GetAsyncJobResultResult::Data GetAsyncJobResultResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/ImageBlindCharacterWatermarkRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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/imageenhan/model/ImageBlindCharacterWatermarkRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::ImageBlindCharacterWatermarkRequest;
+
+ImageBlindCharacterWatermarkRequest::ImageBlindCharacterWatermarkRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindCharacterWatermark")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ImageBlindCharacterWatermarkRequest::~ImageBlindCharacterWatermarkRequest()
+{}
+
+std::string ImageBlindCharacterWatermarkRequest::getWatermarkImageURL()const
+{
+	return watermarkImageURL_;
+}
+
+void ImageBlindCharacterWatermarkRequest::setWatermarkImageURL(const std::string& watermarkImageURL)
+{
+	watermarkImageURL_ = watermarkImageURL;
+	setBodyParameter("WatermarkImageURL", watermarkImageURL);
+}
+
+int ImageBlindCharacterWatermarkRequest::getQualityFactor()const
+{
+	return qualityFactor_;
+}
+
+void ImageBlindCharacterWatermarkRequest::setQualityFactor(int qualityFactor)
+{
+	qualityFactor_ = qualityFactor;
+	setBodyParameter("QualityFactor", std::to_string(qualityFactor));
+}
+
+std::string ImageBlindCharacterWatermarkRequest::getFunctionType()const
+{
+	return functionType_;
+}
+
+void ImageBlindCharacterWatermarkRequest::setFunctionType(const std::string& functionType)
+{
+	functionType_ = functionType;
+	setBodyParameter("FunctionType", functionType);
+}
+
+std::string ImageBlindCharacterWatermarkRequest::getOutputFileType()const
+{
+	return outputFileType_;
+}
+
+void ImageBlindCharacterWatermarkRequest::setOutputFileType(const std::string& outputFileType)
+{
+	outputFileType_ = outputFileType;
+	setBodyParameter("OutputFileType", outputFileType);
+}
+
+std::string ImageBlindCharacterWatermarkRequest::getOriginImageURL()const
+{
+	return originImageURL_;
+}
+
+void ImageBlindCharacterWatermarkRequest::setOriginImageURL(const std::string& originImageURL)
+{
+	originImageURL_ = originImageURL;
+	setBodyParameter("OriginImageURL", originImageURL);
+}
+
+std::string ImageBlindCharacterWatermarkRequest::getText()const
+{
+	return text_;
+}
+
+void ImageBlindCharacterWatermarkRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

imageenhan/src/model/ImageBlindCharacterWatermarkResult.cc

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

imageenhan/src/model/ImageBlindPicWatermarkRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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/imageenhan/model/ImageBlindPicWatermarkRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::ImageBlindPicWatermarkRequest;
+
+ImageBlindPicWatermarkRequest::ImageBlindPicWatermarkRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "ImageBlindPicWatermark")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ImageBlindPicWatermarkRequest::~ImageBlindPicWatermarkRequest()
+{}
+
+std::string ImageBlindPicWatermarkRequest::getWatermarkImageURL()const
+{
+	return watermarkImageURL_;
+}
+
+void ImageBlindPicWatermarkRequest::setWatermarkImageURL(const std::string& watermarkImageURL)
+{
+	watermarkImageURL_ = watermarkImageURL;
+	setBodyParameter("WatermarkImageURL", watermarkImageURL);
+}
+
+int ImageBlindPicWatermarkRequest::getQualityFactor()const
+{
+	return qualityFactor_;
+}
+
+void ImageBlindPicWatermarkRequest::setQualityFactor(int qualityFactor)
+{
+	qualityFactor_ = qualityFactor;
+	setBodyParameter("QualityFactor", std::to_string(qualityFactor));
+}
+
+std::string ImageBlindPicWatermarkRequest::getFunctionType()const
+{
+	return functionType_;
+}
+
+void ImageBlindPicWatermarkRequest::setFunctionType(const std::string& functionType)
+{
+	functionType_ = functionType;
+	setBodyParameter("FunctionType", functionType);
+}
+
+std::string ImageBlindPicWatermarkRequest::getLogoURL()const
+{
+	return logoURL_;
+}
+
+void ImageBlindPicWatermarkRequest::setLogoURL(const std::string& logoURL)
+{
+	logoURL_ = logoURL;
+	setBodyParameter("LogoURL", logoURL);
+}
+
+std::string ImageBlindPicWatermarkRequest::getOutputFileType()const
+{
+	return outputFileType_;
+}
+
+void ImageBlindPicWatermarkRequest::setOutputFileType(const std::string& outputFileType)
+{
+	outputFileType_ = outputFileType;
+	setBodyParameter("OutputFileType", outputFileType);
+}
+
+std::string ImageBlindPicWatermarkRequest::getOriginImageURL()const
+{
+	return originImageURL_;
+}
+
+void ImageBlindPicWatermarkRequest::setOriginImageURL(const std::string& originImageURL)
+{
+	originImageURL_ = originImageURL;
+	setBodyParameter("OriginImageURL", originImageURL);
+}
+

imageenhan/src/model/ImageBlindPicWatermarkResult.cc

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

imageenhan/src/model/ImitatePhotoStyleRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/ImitatePhotoStyleRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::ImitatePhotoStyleRequest;
+
+ImitatePhotoStyleRequest::ImitatePhotoStyleRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "ImitatePhotoStyle")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ImitatePhotoStyleRequest::~ImitatePhotoStyleRequest()
+{}
+
+std::string ImitatePhotoStyleRequest::getStyleUrl()const
+{
+	return styleUrl_;
+}
+
+void ImitatePhotoStyleRequest::setStyleUrl(const std::string& styleUrl)
+{
+	styleUrl_ = styleUrl;
+	setBodyParameter("StyleUrl", styleUrl);
+}
+
+std::string ImitatePhotoStyleRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void ImitatePhotoStyleRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

imageenhan/src/model/ImitatePhotoStyleResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/ImitatePhotoStyleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+ImitatePhotoStyleResult::ImitatePhotoStyleResult() :
+	ServiceResult()
+{}
+
+ImitatePhotoStyleResult::ImitatePhotoStyleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ImitatePhotoStyleResult::~ImitatePhotoStyleResult()
+{}
+
+void ImitatePhotoStyleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ImageURL"].isNull())
+		data_.imageURL = dataNode["ImageURL"].asString();
+
+}
+
+ImitatePhotoStyleResult::Data ImitatePhotoStyleResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/IntelligentCompositionRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/imageenhan/model/IntelligentCompositionRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::IntelligentCompositionRequest;
+
+IntelligentCompositionRequest::IntelligentCompositionRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "IntelligentComposition")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+IntelligentCompositionRequest::~IntelligentCompositionRequest()
+{}
+
+int IntelligentCompositionRequest::getNumBoxes()const
+{
+	return numBoxes_;
+}
+
+void IntelligentCompositionRequest::setNumBoxes(int numBoxes)
+{
+	numBoxes_ = numBoxes;
+	setBodyParameter("NumBoxes", std::to_string(numBoxes));
+}
+
+std::string IntelligentCompositionRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void IntelligentCompositionRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

imageenhan/src/model/IntelligentCompositionResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/imageenhan/model/IntelligentCompositionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+IntelligentCompositionResult::IntelligentCompositionResult() :
+	ServiceResult()
+{}
+
+IntelligentCompositionResult::IntelligentCompositionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+IntelligentCompositionResult::~IntelligentCompositionResult()
+{}
+
+void IntelligentCompositionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allElementsNode = dataNode["Elements"]["Element"];
+	for (auto dataNodeElementsElement : allElementsNode)
+	{
+		Data::Element elementObject;
+		if(!dataNodeElementsElement["MinX"].isNull())
+			elementObject.minX = std::stoi(dataNodeElementsElement["MinX"].asString());
+		if(!dataNodeElementsElement["MinY"].isNull())
+			elementObject.minY = std::stoi(dataNodeElementsElement["MinY"].asString());
+		if(!dataNodeElementsElement["MaxX"].isNull())
+			elementObject.maxX = std::stoi(dataNodeElementsElement["MaxX"].asString());
+		if(!dataNodeElementsElement["MaxY"].isNull())
+			elementObject.maxY = std::stoi(dataNodeElementsElement["MaxY"].asString());
+		if(!dataNodeElementsElement["Score"].isNull())
+			elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
+		data_.elements.push_back(elementObject);
+	}
+
+}
+
+IntelligentCompositionResult::Data IntelligentCompositionResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/MakeSuperResolutionImageRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/imageenhan/model/MakeSuperResolutionImageRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::MakeSuperResolutionImageRequest;
+
+MakeSuperResolutionImageRequest::MakeSuperResolutionImageRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "MakeSuperResolutionImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+MakeSuperResolutionImageRequest::~MakeSuperResolutionImageRequest()
+{}
+
+std::string MakeSuperResolutionImageRequest::getUrl()const
+{
+	return url_;
+}
+
+void MakeSuperResolutionImageRequest::setUrl(const std::string& url)
+{
+	url_ = url;
+	setBodyParameter("Url", url);
+}
+

imageenhan/src/model/MakeSuperResolutionImageResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/MakeSuperResolutionImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+MakeSuperResolutionImageResult::MakeSuperResolutionImageResult() :
+	ServiceResult()
+{}
+
+MakeSuperResolutionImageResult::MakeSuperResolutionImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+MakeSuperResolutionImageResult::~MakeSuperResolutionImageResult()
+{}
+
+void MakeSuperResolutionImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Url"].isNull())
+		data_.url = dataNode["Url"].asString();
+
+}
+
+MakeSuperResolutionImageResult::Data MakeSuperResolutionImageResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/RecolorHDImageRequest.cc

@@ -0,0 +1,110 @@
+/*
+ * 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/imageenhan/model/RecolorHDImageRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::RecolorHDImageRequest;
+
+RecolorHDImageRequest::RecolorHDImageRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "RecolorHDImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RecolorHDImageRequest::~RecolorHDImageRequest()
+{}
+
+std::vector<RecolorHDImageRequest::ColorTemplate> RecolorHDImageRequest::getColorTemplate()const
+{
+	return colorTemplate_;
+}
+
+void RecolorHDImageRequest::setColorTemplate(const std::vector<ColorTemplate>& colorTemplate)
+{
+	colorTemplate_ = colorTemplate;
+	for(int dep1 = 0; dep1!= colorTemplate.size(); dep1++) {
+		auto colorTemplateObj = colorTemplate.at(dep1);
+		std::string colorTemplateObjStr = "ColorTemplate." + std::to_string(dep1 + 1);
+		setParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color);
+	}
+}
+
+std::string RecolorHDImageRequest::getDegree()const
+{
+	return degree_;
+}
+
+void RecolorHDImageRequest::setDegree(const std::string& degree)
+{
+	degree_ = degree;
+	setBodyParameter("Degree", degree);
+}
+
+std::string RecolorHDImageRequest::getUrl()const
+{
+	return url_;
+}
+
+void RecolorHDImageRequest::setUrl(const std::string& url)
+{
+	url_ = url;
+	setBodyParameter("Url", url);
+}
+
+std::string RecolorHDImageRequest::getMode()const
+{
+	return mode_;
+}
+
+void RecolorHDImageRequest::setMode(const std::string& mode)
+{
+	mode_ = mode;
+	setBodyParameter("Mode", mode);
+}
+
+bool RecolorHDImageRequest::getAsync()const
+{
+	return async_;
+}
+
+void RecolorHDImageRequest::setAsync(bool async)
+{
+	async_ = async;
+	setBodyParameter("Async", async ? "true" : "false");
+}
+
+int RecolorHDImageRequest::getColorCount()const
+{
+	return colorCount_;
+}
+
+void RecolorHDImageRequest::setColorCount(int colorCount)
+{
+	colorCount_ = colorCount;
+	setBodyParameter("ColorCount", std::to_string(colorCount));
+}
+
+std::string RecolorHDImageRequest::getRefUrl()const
+{
+	return refUrl_;
+}
+
+void RecolorHDImageRequest::setRefUrl(const std::string& refUrl)
+{
+	refUrl_ = refUrl;
+	setBodyParameter("RefUrl", refUrl);
+}
+

imageenhan/src/model/RecolorHDImageResult.cc

@@ -0,0 +1,53 @@
+/*
+ * 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/imageenhan/model/RecolorHDImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+RecolorHDImageResult::RecolorHDImageResult() :
+	ServiceResult()
+{}
+
+RecolorHDImageResult::RecolorHDImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RecolorHDImageResult::~RecolorHDImageResult()
+{}
+
+void RecolorHDImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+		auto allImageList = dataNode["ImageList"]["ImageList"];
+		for (auto value : allImageList)
+			data_.imageList.push_back(value.asString());
+
+}
+
+RecolorHDImageResult::Data RecolorHDImageResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/RecolorImageRequest.cc

@@ -0,0 +1,88 @@
+/*
+ * 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/imageenhan/model/RecolorImageRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::RecolorImageRequest;
+
+RecolorImageRequest::RecolorImageRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "RecolorImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RecolorImageRequest::~RecolorImageRequest()
+{}
+
+std::vector<RecolorImageRequest::ColorTemplate> RecolorImageRequest::getColorTemplate()const
+{
+	return colorTemplate_;
+}
+
+void RecolorImageRequest::setColorTemplate(const std::vector<ColorTemplate>& colorTemplate)
+{
+	colorTemplate_ = colorTemplate;
+	for(int dep1 = 0; dep1!= colorTemplate.size(); dep1++) {
+		auto colorTemplateObj = colorTemplate.at(dep1);
+		std::string colorTemplateObjStr = "ColorTemplate." + std::to_string(dep1 + 1);
+		setParameter(colorTemplateObjStr + ".Color", colorTemplateObj.color);
+	}
+}
+
+std::string RecolorImageRequest::getUrl()const
+{
+	return url_;
+}
+
+void RecolorImageRequest::setUrl(const std::string& url)
+{
+	url_ = url;
+	setBodyParameter("Url", url);
+}
+
+std::string RecolorImageRequest::getMode()const
+{
+	return mode_;
+}
+
+void RecolorImageRequest::setMode(const std::string& mode)
+{
+	mode_ = mode;
+	setBodyParameter("Mode", mode);
+}
+
+int RecolorImageRequest::getColorCount()const
+{
+	return colorCount_;
+}
+
+void RecolorImageRequest::setColorCount(int colorCount)
+{
+	colorCount_ = colorCount;
+	setBodyParameter("ColorCount", std::to_string(colorCount));
+}
+
+std::string RecolorImageRequest::getRefUrl()const
+{
+	return refUrl_;
+}
+
+void RecolorImageRequest::setRefUrl(const std::string& refUrl)
+{
+	refUrl_ = refUrl;
+	setBodyParameter("RefUrl", refUrl);
+}
+

imageenhan/src/model/RecolorImageResult.cc

@@ -0,0 +1,53 @@
+/*
+ * 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/imageenhan/model/RecolorImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+RecolorImageResult::RecolorImageResult() :
+	ServiceResult()
+{}
+
+RecolorImageResult::RecolorImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RecolorImageResult::~RecolorImageResult()
+{}
+
+void RecolorImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+		auto allImageList = dataNode["ImageList"]["ImageList"];
+		for (auto value : allImageList)
+			data_.imageList.push_back(value.asString());
+
+}
+
+RecolorImageResult::Data RecolorImageResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/RemoveImageSubtitlesRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/imageenhan/model/RemoveImageSubtitlesRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::RemoveImageSubtitlesRequest;
+
+RemoveImageSubtitlesRequest::RemoveImageSubtitlesRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageSubtitles")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RemoveImageSubtitlesRequest::~RemoveImageSubtitlesRequest()
+{}
+
+float RemoveImageSubtitlesRequest::getBH()const
+{
+	return bH_;
+}
+
+void RemoveImageSubtitlesRequest::setBH(float bH)
+{
+	bH_ = bH;
+	setBodyParameter("BH", std::to_string(bH));
+}
+
+float RemoveImageSubtitlesRequest::getBW()const
+{
+	return bW_;
+}
+
+void RemoveImageSubtitlesRequest::setBW(float bW)
+{
+	bW_ = bW;
+	setBodyParameter("BW", std::to_string(bW));
+}
+
+float RemoveImageSubtitlesRequest::getBX()const
+{
+	return bX_;
+}
+
+void RemoveImageSubtitlesRequest::setBX(float bX)
+{
+	bX_ = bX;
+	setBodyParameter("BX", std::to_string(bX));
+}
+
+std::string RemoveImageSubtitlesRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void RemoveImageSubtitlesRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+
+float RemoveImageSubtitlesRequest::getBY()const
+{
+	return bY_;
+}
+
+void RemoveImageSubtitlesRequest::setBY(float bY)
+{
+	bY_ = bY;
+	setBodyParameter("BY", std::to_string(bY));
+}
+

imageenhan/src/model/RemoveImageSubtitlesResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/RemoveImageSubtitlesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+RemoveImageSubtitlesResult::RemoveImageSubtitlesResult() :
+	ServiceResult()
+{}
+
+RemoveImageSubtitlesResult::RemoveImageSubtitlesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RemoveImageSubtitlesResult::~RemoveImageSubtitlesResult()
+{}
+
+void RemoveImageSubtitlesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ImageURL"].isNull())
+		data_.imageURL = dataNode["ImageURL"].asString();
+
+}
+
+RemoveImageSubtitlesResult::Data RemoveImageSubtitlesResult::getData()const
+{
+	return data_;
+}
+

imageenhan/src/model/RemoveImageWatermarkRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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/imageenhan/model/RemoveImageWatermarkRequest.h>
+
+using AlibabaCloud::Imageenhan::Model::RemoveImageWatermarkRequest;
+
+RemoveImageWatermarkRequest::RemoveImageWatermarkRequest() :
+	RpcServiceRequest("imageenhan", "2019-09-30", "RemoveImageWatermark")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RemoveImageWatermarkRequest::~RemoveImageWatermarkRequest()
+{}
+
+std::string RemoveImageWatermarkRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void RemoveImageWatermarkRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

imageenhan/src/model/RemoveImageWatermarkResult.cc

@@ -0,0 +1,52 @@
+/*
+ * 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/imageenhan/model/RemoveImageWatermarkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Imageenhan;
+using namespace AlibabaCloud::Imageenhan::Model;
+
+RemoveImageWatermarkResult::RemoveImageWatermarkResult() :
+	ServiceResult()
+{}
+
+RemoveImageWatermarkResult::RemoveImageWatermarkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RemoveImageWatermarkResult::~RemoveImageWatermarkResult()
+{}
+
+void RemoveImageWatermarkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ImageURL"].isNull())
+		data_.imageURL = dataNode["ImageURL"].asString();
+
+}
+
+RemoveImageWatermarkResult::Data RemoveImageWatermarkResult::getData()const
+{
+	return data_;
+}
+