由尛宏发起的GREEN SDK自动发布, 版本号：1.5.0

Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,6 @@
+2018-04-08 Version: 1.5.0
+1, Add voice asynchronous scan interface.
+
 2018-04-03 Version: 1.4.0
 1, Add APIs for domain transfer in and transfer out.
 2, Add APIs for poll and acknowledge domain task.

CMakeLists.txt

@@ -67,4 +67,5 @@ add_subdirectory(ccc)
 add_subdirectory(teslamaxcompute)
 add_subdirectory(push)
 add_subdirectory(csb)
-add_subdirectory(domain)
+add_subdirectory(domain)
+add_subdirectory(green)

VERSION

@@ -1 +1 @@
-1.4.0
+1.5.0

green/CMakeLists.txt

@@ -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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(green_public_header 
+	include/alibabacloud/green/GreenClient.h
+	include/alibabacloud/green/GreenExport.h )
+
+set(green_public_header_model 
+	include/alibabacloud/green/model/ImageSyncScanRequest.h
+	include/alibabacloud/green/model/ImageSyncScanResult.h
+	include/alibabacloud/green/model/GetPersonsRequest.h
+	include/alibabacloud/green/model/GetPersonsResult.h
+	include/alibabacloud/green/model/GetPersonRequest.h
+	include/alibabacloud/green/model/GetPersonResult.h
+	include/alibabacloud/green/model/DeleteFacesRequest.h
+	include/alibabacloud/green/model/DeleteFacesResult.h
+	include/alibabacloud/green/model/VideoFeedbackRequest.h
+	include/alibabacloud/green/model/VideoFeedbackResult.h
+	include/alibabacloud/green/model/DeletePersonRequest.h
+	include/alibabacloud/green/model/DeletePersonResult.h
+	include/alibabacloud/green/model/VideoAsyncScanResultsRequest.h
+	include/alibabacloud/green/model/VideoAsyncScanResultsResult.h
+	include/alibabacloud/green/model/AddGroupsRequest.h
+	include/alibabacloud/green/model/AddGroupsResult.h
+	include/alibabacloud/green/model/FileAsyncScanRequest.h
+	include/alibabacloud/green/model/FileAsyncScanResult.h
+	include/alibabacloud/green/model/SetPersonRequest.h
+	include/alibabacloud/green/model/SetPersonResult.h
+	include/alibabacloud/green/model/TextFeedbackRequest.h
+	include/alibabacloud/green/model/TextFeedbackResult.h
+	include/alibabacloud/green/model/SearchRequest.h
+	include/alibabacloud/green/model/SearchResult.h
+	include/alibabacloud/green/model/FileAsyncScanResultsRequest.h
+	include/alibabacloud/green/model/FileAsyncScanResultsResult.h
+	include/alibabacloud/green/model/DeleteGroupsRequest.h
+	include/alibabacloud/green/model/DeleteGroupsResult.h
+	include/alibabacloud/green/model/ImageAsyncScanRequest.h
+	include/alibabacloud/green/model/ImageAsyncScanResult.h
+	include/alibabacloud/green/model/VideoAsyncScanRequest.h
+	include/alibabacloud/green/model/VideoAsyncScanResult.h
+	include/alibabacloud/green/model/ImageAsyncScanResultsRequest.h
+	include/alibabacloud/green/model/ImageAsyncScanResultsResult.h
+	include/alibabacloud/green/model/VoiceAsyncScanResultsRequest.h
+	include/alibabacloud/green/model/VoiceAsyncScanResultsResult.h
+	include/alibabacloud/green/model/GetFacesRequest.h
+	include/alibabacloud/green/model/GetFacesResult.h
+	include/alibabacloud/green/model/VoiceAsyncScanRequest.h
+	include/alibabacloud/green/model/VoiceAsyncScanResult.h
+	include/alibabacloud/green/model/GetGroupsRequest.h
+	include/alibabacloud/green/model/GetGroupsResult.h
+	include/alibabacloud/green/model/TextScanRequest.h
+	include/alibabacloud/green/model/TextScanResult.h
+	include/alibabacloud/green/model/ImageScanFeedbackRequest.h
+	include/alibabacloud/green/model/ImageScanFeedbackResult.h
+	include/alibabacloud/green/model/AddPersonRequest.h
+	include/alibabacloud/green/model/AddPersonResult.h
+	include/alibabacloud/green/model/AddFacesRequest.h
+	include/alibabacloud/green/model/AddFacesResult.h )
+
+set(green_src 
+	src/GreenClient.cc
+	src/model/ImageSyncScanRequest.cc
+	src/model/ImageSyncScanResult.cc
+	src/model/GetPersonsRequest.cc
+	src/model/GetPersonsResult.cc
+	src/model/GetPersonRequest.cc
+	src/model/GetPersonResult.cc
+	src/model/DeleteFacesRequest.cc
+	src/model/DeleteFacesResult.cc
+	src/model/VideoFeedbackRequest.cc
+	src/model/VideoFeedbackResult.cc
+	src/model/DeletePersonRequest.cc
+	src/model/DeletePersonResult.cc
+	src/model/VideoAsyncScanResultsRequest.cc
+	src/model/VideoAsyncScanResultsResult.cc
+	src/model/AddGroupsRequest.cc
+	src/model/AddGroupsResult.cc
+	src/model/FileAsyncScanRequest.cc
+	src/model/FileAsyncScanResult.cc
+	src/model/SetPersonRequest.cc
+	src/model/SetPersonResult.cc
+	src/model/TextFeedbackRequest.cc
+	src/model/TextFeedbackResult.cc
+	src/model/SearchRequest.cc
+	src/model/SearchResult.cc
+	src/model/FileAsyncScanResultsRequest.cc
+	src/model/FileAsyncScanResultsResult.cc
+	src/model/DeleteGroupsRequest.cc
+	src/model/DeleteGroupsResult.cc
+	src/model/ImageAsyncScanRequest.cc
+	src/model/ImageAsyncScanResult.cc
+	src/model/VideoAsyncScanRequest.cc
+	src/model/VideoAsyncScanResult.cc
+	src/model/ImageAsyncScanResultsRequest.cc
+	src/model/ImageAsyncScanResultsResult.cc
+	src/model/VoiceAsyncScanResultsRequest.cc
+	src/model/VoiceAsyncScanResultsResult.cc
+	src/model/GetFacesRequest.cc
+	src/model/GetFacesResult.cc
+	src/model/VoiceAsyncScanRequest.cc
+	src/model/VoiceAsyncScanResult.cc
+	src/model/GetGroupsRequest.cc
+	src/model/GetGroupsResult.cc
+	src/model/TextScanRequest.cc
+	src/model/TextScanResult.cc
+	src/model/ImageScanFeedbackRequest.cc
+	src/model/ImageScanFeedbackResult.cc
+	src/model/AddPersonRequest.cc
+	src/model/AddPersonResult.cc
+	src/model/AddFacesRequest.cc
+	src/model/AddFacesResult.cc )
+
+add_library(green ${LIB_TYPE}
+	${green_public_header}
+	${green_public_header_model}
+	${green_src})
+
+set_target_properties(green
+	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}green
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(green
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_GREEN_LIBRARY)
+endif()
+
+target_include_directories(green
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(green
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(green
+		jsoncpp)
+	target_include_directories(green
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(green
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(green
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(green
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(green
+		jsoncpp)
+endif()
+
+install(FILES ${green_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/green)
+install(FILES ${green_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/green/model)
+install(TARGETS green
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

green/include/alibabacloud/green/GreenClient.h

@@ -0,0 +1,246 @@
+/*
+ * 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_GREEN_GREENCLIENT_H_
+#define ALIBABACLOUD_GREEN_GREENCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RoaServiceClient.h>
+#include "GreenExport.h"
+#include "model/ImageSyncScanRequest.h"
+#include "model/ImageSyncScanResult.h"
+#include "model/GetPersonsRequest.h"
+#include "model/GetPersonsResult.h"
+#include "model/GetPersonRequest.h"
+#include "model/GetPersonResult.h"
+#include "model/DeleteFacesRequest.h"
+#include "model/DeleteFacesResult.h"
+#include "model/VideoFeedbackRequest.h"
+#include "model/VideoFeedbackResult.h"
+#include "model/DeletePersonRequest.h"
+#include "model/DeletePersonResult.h"
+#include "model/VideoAsyncScanResultsRequest.h"
+#include "model/VideoAsyncScanResultsResult.h"
+#include "model/AddGroupsRequest.h"
+#include "model/AddGroupsResult.h"
+#include "model/FileAsyncScanRequest.h"
+#include "model/FileAsyncScanResult.h"
+#include "model/SetPersonRequest.h"
+#include "model/SetPersonResult.h"
+#include "model/TextFeedbackRequest.h"
+#include "model/TextFeedbackResult.h"
+#include "model/SearchRequest.h"
+#include "model/SearchResult.h"
+#include "model/FileAsyncScanResultsRequest.h"
+#include "model/FileAsyncScanResultsResult.h"
+#include "model/DeleteGroupsRequest.h"
+#include "model/DeleteGroupsResult.h"
+#include "model/ImageAsyncScanRequest.h"
+#include "model/ImageAsyncScanResult.h"
+#include "model/VideoAsyncScanRequest.h"
+#include "model/VideoAsyncScanResult.h"
+#include "model/ImageAsyncScanResultsRequest.h"
+#include "model/ImageAsyncScanResultsResult.h"
+#include "model/VoiceAsyncScanResultsRequest.h"
+#include "model/VoiceAsyncScanResultsResult.h"
+#include "model/GetFacesRequest.h"
+#include "model/GetFacesResult.h"
+#include "model/VoiceAsyncScanRequest.h"
+#include "model/VoiceAsyncScanResult.h"
+#include "model/GetGroupsRequest.h"
+#include "model/GetGroupsResult.h"
+#include "model/TextScanRequest.h"
+#include "model/TextScanResult.h"
+#include "model/ImageScanFeedbackRequest.h"
+#include "model/ImageScanFeedbackResult.h"
+#include "model/AddPersonRequest.h"
+#include "model/AddPersonResult.h"
+#include "model/AddFacesRequest.h"
+#include "model/AddFacesResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		class ALIBABACLOUD_GREEN_EXPORT GreenClient : public RoaServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::ImageSyncScanResult> ImageSyncScanOutcome;
+			typedef std::future<ImageSyncScanOutcome> ImageSyncScanOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::ImageSyncScanRequest&, const ImageSyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageSyncScanAsyncHandler;
+			typedef Outcome<Error, Model::GetPersonsResult> GetPersonsOutcome;
+			typedef std::future<GetPersonsOutcome> GetPersonsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::GetPersonsRequest&, const GetPersonsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPersonsAsyncHandler;
+			typedef Outcome<Error, Model::GetPersonResult> GetPersonOutcome;
+			typedef std::future<GetPersonOutcome> GetPersonOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::GetPersonRequest&, const GetPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPersonAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFacesResult> DeleteFacesOutcome;
+			typedef std::future<DeleteFacesOutcome> DeleteFacesOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::DeleteFacesRequest&, const DeleteFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFacesAsyncHandler;
+			typedef Outcome<Error, Model::VideoFeedbackResult> VideoFeedbackOutcome;
+			typedef std::future<VideoFeedbackOutcome> VideoFeedbackOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::VideoFeedbackRequest&, const VideoFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoFeedbackAsyncHandler;
+			typedef Outcome<Error, Model::DeletePersonResult> DeletePersonOutcome;
+			typedef std::future<DeletePersonOutcome> DeletePersonOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::DeletePersonRequest&, const DeletePersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePersonAsyncHandler;
+			typedef Outcome<Error, Model::VideoAsyncScanResultsResult> VideoAsyncScanResultsOutcome;
+			typedef std::future<VideoAsyncScanResultsOutcome> VideoAsyncScanResultsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::VideoAsyncScanResultsRequest&, const VideoAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoAsyncScanResultsAsyncHandler;
+			typedef Outcome<Error, Model::AddGroupsResult> AddGroupsOutcome;
+			typedef std::future<AddGroupsOutcome> AddGroupsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::AddGroupsRequest&, const AddGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddGroupsAsyncHandler;
+			typedef Outcome<Error, Model::FileAsyncScanResult> FileAsyncScanOutcome;
+			typedef std::future<FileAsyncScanOutcome> FileAsyncScanOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::FileAsyncScanRequest&, const FileAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FileAsyncScanAsyncHandler;
+			typedef Outcome<Error, Model::SetPersonResult> SetPersonOutcome;
+			typedef std::future<SetPersonOutcome> SetPersonOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::SetPersonRequest&, const SetPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetPersonAsyncHandler;
+			typedef Outcome<Error, Model::TextFeedbackResult> TextFeedbackOutcome;
+			typedef std::future<TextFeedbackOutcome> TextFeedbackOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::TextFeedbackRequest&, const TextFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TextFeedbackAsyncHandler;
+			typedef Outcome<Error, Model::SearchResult> SearchOutcome;
+			typedef std::future<SearchOutcome> SearchOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::SearchRequest&, const SearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchAsyncHandler;
+			typedef Outcome<Error, Model::FileAsyncScanResultsResult> FileAsyncScanResultsOutcome;
+			typedef std::future<FileAsyncScanResultsOutcome> FileAsyncScanResultsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::FileAsyncScanResultsRequest&, const FileAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FileAsyncScanResultsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGroupsResult> DeleteGroupsOutcome;
+			typedef std::future<DeleteGroupsOutcome> DeleteGroupsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::DeleteGroupsRequest&, const DeleteGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ImageAsyncScanResult> ImageAsyncScanOutcome;
+			typedef std::future<ImageAsyncScanOutcome> ImageAsyncScanOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::ImageAsyncScanRequest&, const ImageAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageAsyncScanAsyncHandler;
+			typedef Outcome<Error, Model::VideoAsyncScanResult> VideoAsyncScanOutcome;
+			typedef std::future<VideoAsyncScanOutcome> VideoAsyncScanOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::VideoAsyncScanRequest&, const VideoAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VideoAsyncScanAsyncHandler;
+			typedef Outcome<Error, Model::ImageAsyncScanResultsResult> ImageAsyncScanResultsOutcome;
+			typedef std::future<ImageAsyncScanResultsOutcome> ImageAsyncScanResultsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::ImageAsyncScanResultsRequest&, const ImageAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageAsyncScanResultsAsyncHandler;
+			typedef Outcome<Error, Model::VoiceAsyncScanResultsResult> VoiceAsyncScanResultsOutcome;
+			typedef std::future<VoiceAsyncScanResultsOutcome> VoiceAsyncScanResultsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::VoiceAsyncScanResultsRequest&, const VoiceAsyncScanResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VoiceAsyncScanResultsAsyncHandler;
+			typedef Outcome<Error, Model::GetFacesResult> GetFacesOutcome;
+			typedef std::future<GetFacesOutcome> GetFacesOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::GetFacesRequest&, const GetFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFacesAsyncHandler;
+			typedef Outcome<Error, Model::VoiceAsyncScanResult> VoiceAsyncScanOutcome;
+			typedef std::future<VoiceAsyncScanOutcome> VoiceAsyncScanOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::VoiceAsyncScanRequest&, const VoiceAsyncScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VoiceAsyncScanAsyncHandler;
+			typedef Outcome<Error, Model::GetGroupsResult> GetGroupsOutcome;
+			typedef std::future<GetGroupsOutcome> GetGroupsOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::GetGroupsRequest&, const GetGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGroupsAsyncHandler;
+			typedef Outcome<Error, Model::TextScanResult> TextScanOutcome;
+			typedef std::future<TextScanOutcome> TextScanOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::TextScanRequest&, const TextScanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TextScanAsyncHandler;
+			typedef Outcome<Error, Model::ImageScanFeedbackResult> ImageScanFeedbackOutcome;
+			typedef std::future<ImageScanFeedbackOutcome> ImageScanFeedbackOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::ImageScanFeedbackRequest&, const ImageScanFeedbackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImageScanFeedbackAsyncHandler;
+			typedef Outcome<Error, Model::AddPersonResult> AddPersonOutcome;
+			typedef std::future<AddPersonOutcome> AddPersonOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::AddPersonRequest&, const AddPersonOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddPersonAsyncHandler;
+			typedef Outcome<Error, Model::AddFacesResult> AddFacesOutcome;
+			typedef std::future<AddFacesOutcome> AddFacesOutcomeCallable;
+			typedef std::function<void(const GreenClient*, const Model::AddFacesRequest&, const AddFacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFacesAsyncHandler;
+
+			GreenClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			GreenClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			GreenClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~GreenClient();
+			ImageSyncScanOutcome imageSyncScan(const Model::ImageSyncScanRequest &request)const;
+			void imageSyncScanAsync(const Model::ImageSyncScanRequest& request, const ImageSyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImageSyncScanOutcomeCallable imageSyncScanCallable(const Model::ImageSyncScanRequest& request) const;
+			GetPersonsOutcome getPersons(const Model::GetPersonsRequest &request)const;
+			void getPersonsAsync(const Model::GetPersonsRequest& request, const GetPersonsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPersonsOutcomeCallable getPersonsCallable(const Model::GetPersonsRequest& request) const;
+			GetPersonOutcome getPerson(const Model::GetPersonRequest &request)const;
+			void getPersonAsync(const Model::GetPersonRequest& request, const GetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPersonOutcomeCallable getPersonCallable(const Model::GetPersonRequest& request) const;
+			DeleteFacesOutcome deleteFaces(const Model::DeleteFacesRequest &request)const;
+			void deleteFacesAsync(const Model::DeleteFacesRequest& request, const DeleteFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFacesOutcomeCallable deleteFacesCallable(const Model::DeleteFacesRequest& request) const;
+			VideoFeedbackOutcome videoFeedback(const Model::VideoFeedbackRequest &request)const;
+			void videoFeedbackAsync(const Model::VideoFeedbackRequest& request, const VideoFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VideoFeedbackOutcomeCallable videoFeedbackCallable(const Model::VideoFeedbackRequest& request) const;
+			DeletePersonOutcome deletePerson(const Model::DeletePersonRequest &request)const;
+			void deletePersonAsync(const Model::DeletePersonRequest& request, const DeletePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePersonOutcomeCallable deletePersonCallable(const Model::DeletePersonRequest& request) const;
+			VideoAsyncScanResultsOutcome videoAsyncScanResults(const Model::VideoAsyncScanResultsRequest &request)const;
+			void videoAsyncScanResultsAsync(const Model::VideoAsyncScanResultsRequest& request, const VideoAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VideoAsyncScanResultsOutcomeCallable videoAsyncScanResultsCallable(const Model::VideoAsyncScanResultsRequest& request) const;
+			AddGroupsOutcome addGroups(const Model::AddGroupsRequest &request)const;
+			void addGroupsAsync(const Model::AddGroupsRequest& request, const AddGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddGroupsOutcomeCallable addGroupsCallable(const Model::AddGroupsRequest& request) const;
+			FileAsyncScanOutcome fileAsyncScan(const Model::FileAsyncScanRequest &request)const;
+			void fileAsyncScanAsync(const Model::FileAsyncScanRequest& request, const FileAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FileAsyncScanOutcomeCallable fileAsyncScanCallable(const Model::FileAsyncScanRequest& request) const;
+			SetPersonOutcome setPerson(const Model::SetPersonRequest &request)const;
+			void setPersonAsync(const Model::SetPersonRequest& request, const SetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetPersonOutcomeCallable setPersonCallable(const Model::SetPersonRequest& request) const;
+			TextFeedbackOutcome textFeedback(const Model::TextFeedbackRequest &request)const;
+			void textFeedbackAsync(const Model::TextFeedbackRequest& request, const TextFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TextFeedbackOutcomeCallable textFeedbackCallable(const Model::TextFeedbackRequest& request) const;
+			SearchOutcome search(const Model::SearchRequest &request)const;
+			void searchAsync(const Model::SearchRequest& request, const SearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchOutcomeCallable searchCallable(const Model::SearchRequest& request) const;
+			FileAsyncScanResultsOutcome fileAsyncScanResults(const Model::FileAsyncScanResultsRequest &request)const;
+			void fileAsyncScanResultsAsync(const Model::FileAsyncScanResultsRequest& request, const FileAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FileAsyncScanResultsOutcomeCallable fileAsyncScanResultsCallable(const Model::FileAsyncScanResultsRequest& request) const;
+			DeleteGroupsOutcome deleteGroups(const Model::DeleteGroupsRequest &request)const;
+			void deleteGroupsAsync(const Model::DeleteGroupsRequest& request, const DeleteGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGroupsOutcomeCallable deleteGroupsCallable(const Model::DeleteGroupsRequest& request) const;
+			ImageAsyncScanOutcome imageAsyncScan(const Model::ImageAsyncScanRequest &request)const;
+			void imageAsyncScanAsync(const Model::ImageAsyncScanRequest& request, const ImageAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImageAsyncScanOutcomeCallable imageAsyncScanCallable(const Model::ImageAsyncScanRequest& request) const;
+			VideoAsyncScanOutcome videoAsyncScan(const Model::VideoAsyncScanRequest &request)const;
+			void videoAsyncScanAsync(const Model::VideoAsyncScanRequest& request, const VideoAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VideoAsyncScanOutcomeCallable videoAsyncScanCallable(const Model::VideoAsyncScanRequest& request) const;
+			ImageAsyncScanResultsOutcome imageAsyncScanResults(const Model::ImageAsyncScanResultsRequest &request)const;
+			void imageAsyncScanResultsAsync(const Model::ImageAsyncScanResultsRequest& request, const ImageAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImageAsyncScanResultsOutcomeCallable imageAsyncScanResultsCallable(const Model::ImageAsyncScanResultsRequest& request) const;
+			VoiceAsyncScanResultsOutcome voiceAsyncScanResults(const Model::VoiceAsyncScanResultsRequest &request)const;
+			void voiceAsyncScanResultsAsync(const Model::VoiceAsyncScanResultsRequest& request, const VoiceAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VoiceAsyncScanResultsOutcomeCallable voiceAsyncScanResultsCallable(const Model::VoiceAsyncScanResultsRequest& request) const;
+			GetFacesOutcome getFaces(const Model::GetFacesRequest &request)const;
+			void getFacesAsync(const Model::GetFacesRequest& request, const GetFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFacesOutcomeCallable getFacesCallable(const Model::GetFacesRequest& request) const;
+			VoiceAsyncScanOutcome voiceAsyncScan(const Model::VoiceAsyncScanRequest &request)const;
+			void voiceAsyncScanAsync(const Model::VoiceAsyncScanRequest& request, const VoiceAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VoiceAsyncScanOutcomeCallable voiceAsyncScanCallable(const Model::VoiceAsyncScanRequest& request) const;
+			GetGroupsOutcome getGroups(const Model::GetGroupsRequest &request)const;
+			void getGroupsAsync(const Model::GetGroupsRequest& request, const GetGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetGroupsOutcomeCallable getGroupsCallable(const Model::GetGroupsRequest& request) const;
+			TextScanOutcome textScan(const Model::TextScanRequest &request)const;
+			void textScanAsync(const Model::TextScanRequest& request, const TextScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TextScanOutcomeCallable textScanCallable(const Model::TextScanRequest& request) const;
+			ImageScanFeedbackOutcome imageScanFeedback(const Model::ImageScanFeedbackRequest &request)const;
+			void imageScanFeedbackAsync(const Model::ImageScanFeedbackRequest& request, const ImageScanFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImageScanFeedbackOutcomeCallable imageScanFeedbackCallable(const Model::ImageScanFeedbackRequest& request) const;
+			AddPersonOutcome addPerson(const Model::AddPersonRequest &request)const;
+			void addPersonAsync(const Model::AddPersonRequest& request, const AddPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddPersonOutcomeCallable addPersonCallable(const Model::AddPersonRequest& request) const;
+			AddFacesOutcome addFaces(const Model::AddFacesRequest &request)const;
+			void addFacesAsync(const Model::AddFacesRequest& request, const AddFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddFacesOutcomeCallable addFacesCallable(const Model::AddFacesRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_GREEN_GREENCLIENT_H_

green/include/alibabacloud/green/GreenExport.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_GREEN_GREENEXPORT_H_
+#define ALIBABACLOUD_GREEN_GREENEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_GREEN_LIBRARY)
+#		define ALIBABACLOUD_GREEN_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_GREEN_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_GREEN_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_GREEN_GREENEXPORT_H_

green/include/alibabacloud/green/model/AddFacesRequest.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_GREEN_MODEL_ADDFACESREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_ADDFACESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT AddFacesRequest : public RoaServiceRequest
+			{
+
+			public:
+				AddFacesRequest();
+				~AddFacesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_ADDFACESREQUEST_H_

green/include/alibabacloud/green/model/AddFacesResult.h

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

green/include/alibabacloud/green/model/AddGroupsRequest.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_GREEN_MODEL_ADDGROUPSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_ADDGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT AddGroupsRequest : public RoaServiceRequest
+			{
+
+			public:
+				AddGroupsRequest();
+				~AddGroupsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_ADDGROUPSREQUEST_H_

green/include/alibabacloud/green/model/AddGroupsResult.h

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

green/include/alibabacloud/green/model/AddPersonRequest.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_GREEN_MODEL_ADDPERSONREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_ADDPERSONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT AddPersonRequest : public RoaServiceRequest
+			{
+
+			public:
+				AddPersonRequest();
+				~AddPersonRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_ADDPERSONREQUEST_H_

green/include/alibabacloud/green/model/AddPersonResult.h

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

green/include/alibabacloud/green/model/DeleteFacesRequest.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_GREEN_MODEL_DELETEFACESREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_DELETEFACESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT DeleteFacesRequest : public RoaServiceRequest
+			{
+
+			public:
+				DeleteFacesRequest();
+				~DeleteFacesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEFACESREQUEST_H_

green/include/alibabacloud/green/model/DeleteFacesResult.h

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

green/include/alibabacloud/green/model/DeleteGroupsRequest.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_GREEN_MODEL_DELETEGROUPSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_DELETEGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT DeleteGroupsRequest : public RoaServiceRequest
+			{
+
+			public:
+				DeleteGroupsRequest();
+				~DeleteGroupsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEGROUPSREQUEST_H_

green/include/alibabacloud/green/model/DeleteGroupsResult.h

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

green/include/alibabacloud/green/model/DeletePersonRequest.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_GREEN_MODEL_DELETEPERSONREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_DELETEPERSONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT DeletePersonRequest : public RoaServiceRequest
+			{
+
+			public:
+				DeletePersonRequest();
+				~DeletePersonRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_DELETEPERSONREQUEST_H_

green/include/alibabacloud/green/model/DeletePersonResult.h

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

green/include/alibabacloud/green/model/FileAsyncScanRequest.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_GREEN_MODEL_FILEASYNCSCANREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT FileAsyncScanRequest : public RoaServiceRequest
+			{
+
+			public:
+				FileAsyncScanRequest();
+				~FileAsyncScanRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANREQUEST_H_

green/include/alibabacloud/green/model/FileAsyncScanResult.h

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

green/include/alibabacloud/green/model/FileAsyncScanResultsRequest.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_GREEN_MODEL_FILEASYNCSCANRESULTSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANRESULTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT FileAsyncScanResultsRequest : public RoaServiceRequest
+			{
+
+			public:
+				FileAsyncScanResultsRequest();
+				~FileAsyncScanResultsRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_FILEASYNCSCANRESULTSREQUEST_H_

green/include/alibabacloud/green/model/FileAsyncScanResultsResult.h

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

green/include/alibabacloud/green/model/GetFacesRequest.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_GREEN_MODEL_GETFACESREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_GETFACESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT GetFacesRequest : public RoaServiceRequest
+			{
+
+			public:
+				GetFacesRequest();
+				~GetFacesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_GETFACESREQUEST_H_

green/include/alibabacloud/green/model/GetFacesResult.h

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

green/include/alibabacloud/green/model/GetGroupsRequest.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_GREEN_MODEL_GETGROUPSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_GETGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT GetGroupsRequest : public RoaServiceRequest
+			{
+
+			public:
+				GetGroupsRequest();
+				~GetGroupsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_GETGROUPSREQUEST_H_

green/include/alibabacloud/green/model/GetGroupsResult.h

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

green/include/alibabacloud/green/model/GetPersonRequest.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_GREEN_MODEL_GETPERSONREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_GETPERSONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT GetPersonRequest : public RoaServiceRequest
+			{
+
+			public:
+				GetPersonRequest();
+				~GetPersonRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_GETPERSONREQUEST_H_

green/include/alibabacloud/green/model/GetPersonResult.h

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

green/include/alibabacloud/green/model/GetPersonsRequest.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_GREEN_MODEL_GETPERSONSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_GETPERSONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT GetPersonsRequest : public RoaServiceRequest
+			{
+
+			public:
+				GetPersonsRequest();
+				~GetPersonsRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_GETPERSONSREQUEST_H_

green/include/alibabacloud/green/model/GetPersonsResult.h

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

green/include/alibabacloud/green/model/ImageAsyncScanRequest.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_GREEN_MODEL_IMAGEASYNCSCANREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT ImageAsyncScanRequest : public RoaServiceRequest
+			{
+
+			public:
+				ImageAsyncScanRequest();
+				~ImageAsyncScanRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANREQUEST_H_

green/include/alibabacloud/green/model/ImageAsyncScanResult.h

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

green/include/alibabacloud/green/model/ImageAsyncScanResultsRequest.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_GREEN_MODEL_IMAGEASYNCSCANRESULTSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANRESULTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT ImageAsyncScanResultsRequest : public RoaServiceRequest
+			{
+
+			public:
+				ImageAsyncScanResultsRequest();
+				~ImageAsyncScanResultsRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGEASYNCSCANRESULTSREQUEST_H_

green/include/alibabacloud/green/model/ImageAsyncScanResultsResult.h

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

green/include/alibabacloud/green/model/ImageScanFeedbackRequest.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_GREEN_MODEL_IMAGESCANFEEDBACKREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_IMAGESCANFEEDBACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT ImageScanFeedbackRequest : public RoaServiceRequest
+			{
+
+			public:
+				ImageScanFeedbackRequest();
+				~ImageScanFeedbackRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGESCANFEEDBACKREQUEST_H_

green/include/alibabacloud/green/model/ImageScanFeedbackResult.h

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

green/include/alibabacloud/green/model/ImageSyncScanRequest.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_GREEN_MODEL_IMAGESYNCSCANREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_IMAGESYNCSCANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT ImageSyncScanRequest : public RoaServiceRequest
+			{
+
+			public:
+				ImageSyncScanRequest();
+				~ImageSyncScanRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_IMAGESYNCSCANREQUEST_H_

green/include/alibabacloud/green/model/ImageSyncScanResult.h

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

green/include/alibabacloud/green/model/SearchRequest.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_GREEN_MODEL_SEARCHREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_SEARCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT SearchRequest : public RoaServiceRequest
+			{
+
+			public:
+				SearchRequest();
+				~SearchRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_SEARCHREQUEST_H_

green/include/alibabacloud/green/model/SearchResult.h

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

green/include/alibabacloud/green/model/SetPersonRequest.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_GREEN_MODEL_SETPERSONREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_SETPERSONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT SetPersonRequest : public RoaServiceRequest
+			{
+
+			public:
+				SetPersonRequest();
+				~SetPersonRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string regionId_;
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_SETPERSONREQUEST_H_

green/include/alibabacloud/green/model/SetPersonResult.h

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

green/include/alibabacloud/green/model/TextFeedbackRequest.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_GREEN_MODEL_TEXTFEEDBACKREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_TEXTFEEDBACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT TextFeedbackRequest : public RoaServiceRequest
+			{
+
+			public:
+				TextFeedbackRequest();
+				~TextFeedbackRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_TEXTFEEDBACKREQUEST_H_

green/include/alibabacloud/green/model/TextFeedbackResult.h

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

green/include/alibabacloud/green/model/TextScanRequest.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_GREEN_MODEL_TEXTSCANREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_TEXTSCANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT TextScanRequest : public RoaServiceRequest
+			{
+
+			public:
+				TextScanRequest();
+				~TextScanRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_TEXTSCANREQUEST_H_

green/include/alibabacloud/green/model/TextScanResult.h

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

green/include/alibabacloud/green/model/VideoAsyncScanRequest.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_GREEN_MODEL_VIDEOASYNCSCANREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT VideoAsyncScanRequest : public RoaServiceRequest
+			{
+
+			public:
+				VideoAsyncScanRequest();
+				~VideoAsyncScanRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANREQUEST_H_

green/include/alibabacloud/green/model/VideoAsyncScanResult.h

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

green/include/alibabacloud/green/model/VideoAsyncScanResultsRequest.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_GREEN_MODEL_VIDEOASYNCSCANRESULTSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANRESULTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT VideoAsyncScanResultsRequest : public RoaServiceRequest
+			{
+
+			public:
+				VideoAsyncScanResultsRequest();
+				~VideoAsyncScanResultsRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_VIDEOASYNCSCANRESULTSREQUEST_H_

green/include/alibabacloud/green/model/VideoAsyncScanResultsResult.h

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

green/include/alibabacloud/green/model/VideoFeedbackRequest.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_GREEN_MODEL_VIDEOFEEDBACKREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_VIDEOFEEDBACKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT VideoFeedbackRequest : public RoaServiceRequest
+			{
+
+			public:
+				VideoFeedbackRequest();
+				~VideoFeedbackRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_VIDEOFEEDBACKREQUEST_H_

green/include/alibabacloud/green/model/VideoFeedbackResult.h

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

green/include/alibabacloud/green/model/VoiceAsyncScanRequest.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_GREEN_MODEL_VOICEASYNCSCANREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT VoiceAsyncScanRequest : public RoaServiceRequest
+			{
+
+			public:
+				VoiceAsyncScanRequest();
+				~VoiceAsyncScanRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANREQUEST_H_

green/include/alibabacloud/green/model/VoiceAsyncScanResult.h

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

green/include/alibabacloud/green/model/VoiceAsyncScanResultsRequest.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_GREEN_MODEL_VOICEASYNCSCANRESULTSREQUEST_H_
+#define ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANRESULTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/green/GreenExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Green
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_GREEN_EXPORT VoiceAsyncScanResultsRequest : public RoaServiceRequest
+			{
+
+			public:
+				VoiceAsyncScanResultsRequest();
+				~VoiceAsyncScanResultsRequest();
+
+				std::string getClientInfo()const;
+				void setClientInfo(const std::string& clientInfo);
+
+            private:
+				std::string clientInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_GREEN_MODEL_VOICEASYNCSCANRESULTSREQUEST_H_

green/include/alibabacloud/green/model/VoiceAsyncScanResultsResult.h

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

green/src/GreenClient.cc

@@ -0,0 +1,953 @@
+/*
+ * 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/green/GreenClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Green;
+using namespace AlibabaCloud::Green::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "Green";
+}
+
+GreenClient::GreenClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RoaServiceClient(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, "green");
+}
+
+GreenClient::GreenClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "green");
+}
+
+GreenClient::GreenClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RoaServiceClient(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, "green");
+}
+
+GreenClient::~GreenClient()
+{}
+
+GreenClient::ImageSyncScanOutcome GreenClient::imageSyncScan(const ImageSyncScanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImageSyncScanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImageSyncScanOutcome(ImageSyncScanResult(outcome.result()));
+	else
+		return ImageSyncScanOutcome(outcome.error());
+}
+
+void GreenClient::imageSyncScanAsync(const ImageSyncScanRequest& request, const ImageSyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imageSyncScan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::ImageSyncScanOutcomeCallable GreenClient::imageSyncScanCallable(const ImageSyncScanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImageSyncScanOutcome()>>(
+			[this, request]()
+			{
+			return this->imageSyncScan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::GetPersonsOutcome GreenClient::getPersons(const GetPersonsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPersonsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPersonsOutcome(GetPersonsResult(outcome.result()));
+	else
+		return GetPersonsOutcome(outcome.error());
+}
+
+void GreenClient::getPersonsAsync(const GetPersonsRequest& request, const GetPersonsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPersons(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::GetPersonsOutcomeCallable GreenClient::getPersonsCallable(const GetPersonsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPersonsOutcome()>>(
+			[this, request]()
+			{
+			return this->getPersons(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::GetPersonOutcome GreenClient::getPerson(const GetPersonRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPersonOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPersonOutcome(GetPersonResult(outcome.result()));
+	else
+		return GetPersonOutcome(outcome.error());
+}
+
+void GreenClient::getPersonAsync(const GetPersonRequest& request, const GetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPerson(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::GetPersonOutcomeCallable GreenClient::getPersonCallable(const GetPersonRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPersonOutcome()>>(
+			[this, request]()
+			{
+			return this->getPerson(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::DeleteFacesOutcome GreenClient::deleteFaces(const DeleteFacesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFacesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFacesOutcome(DeleteFacesResult(outcome.result()));
+	else
+		return DeleteFacesOutcome(outcome.error());
+}
+
+void GreenClient::deleteFacesAsync(const DeleteFacesRequest& request, const DeleteFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaces(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::DeleteFacesOutcomeCallable GreenClient::deleteFacesCallable(const DeleteFacesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFacesOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaces(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::VideoFeedbackOutcome GreenClient::videoFeedback(const VideoFeedbackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VideoFeedbackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VideoFeedbackOutcome(VideoFeedbackResult(outcome.result()));
+	else
+		return VideoFeedbackOutcome(outcome.error());
+}
+
+void GreenClient::videoFeedbackAsync(const VideoFeedbackRequest& request, const VideoFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, videoFeedback(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::VideoFeedbackOutcomeCallable GreenClient::videoFeedbackCallable(const VideoFeedbackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VideoFeedbackOutcome()>>(
+			[this, request]()
+			{
+			return this->videoFeedback(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::DeletePersonOutcome GreenClient::deletePerson(const DeletePersonRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePersonOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePersonOutcome(DeletePersonResult(outcome.result()));
+	else
+		return DeletePersonOutcome(outcome.error());
+}
+
+void GreenClient::deletePersonAsync(const DeletePersonRequest& request, const DeletePersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePerson(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::DeletePersonOutcomeCallable GreenClient::deletePersonCallable(const DeletePersonRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePersonOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePerson(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::VideoAsyncScanResultsOutcome GreenClient::videoAsyncScanResults(const VideoAsyncScanResultsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VideoAsyncScanResultsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VideoAsyncScanResultsOutcome(VideoAsyncScanResultsResult(outcome.result()));
+	else
+		return VideoAsyncScanResultsOutcome(outcome.error());
+}
+
+void GreenClient::videoAsyncScanResultsAsync(const VideoAsyncScanResultsRequest& request, const VideoAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, videoAsyncScanResults(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::VideoAsyncScanResultsOutcomeCallable GreenClient::videoAsyncScanResultsCallable(const VideoAsyncScanResultsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VideoAsyncScanResultsOutcome()>>(
+			[this, request]()
+			{
+			return this->videoAsyncScanResults(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::AddGroupsOutcome GreenClient::addGroups(const AddGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddGroupsOutcome(AddGroupsResult(outcome.result()));
+	else
+		return AddGroupsOutcome(outcome.error());
+}
+
+void GreenClient::addGroupsAsync(const AddGroupsRequest& request, const AddGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::AddGroupsOutcomeCallable GreenClient::addGroupsCallable(const AddGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->addGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::FileAsyncScanOutcome GreenClient::fileAsyncScan(const FileAsyncScanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FileAsyncScanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FileAsyncScanOutcome(FileAsyncScanResult(outcome.result()));
+	else
+		return FileAsyncScanOutcome(outcome.error());
+}
+
+void GreenClient::fileAsyncScanAsync(const FileAsyncScanRequest& request, const FileAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, fileAsyncScan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::FileAsyncScanOutcomeCallable GreenClient::fileAsyncScanCallable(const FileAsyncScanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FileAsyncScanOutcome()>>(
+			[this, request]()
+			{
+			return this->fileAsyncScan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::SetPersonOutcome GreenClient::setPerson(const SetPersonRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetPersonOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetPersonOutcome(SetPersonResult(outcome.result()));
+	else
+		return SetPersonOutcome(outcome.error());
+}
+
+void GreenClient::setPersonAsync(const SetPersonRequest& request, const SetPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setPerson(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::SetPersonOutcomeCallable GreenClient::setPersonCallable(const SetPersonRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetPersonOutcome()>>(
+			[this, request]()
+			{
+			return this->setPerson(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::TextFeedbackOutcome GreenClient::textFeedback(const TextFeedbackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TextFeedbackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TextFeedbackOutcome(TextFeedbackResult(outcome.result()));
+	else
+		return TextFeedbackOutcome(outcome.error());
+}
+
+void GreenClient::textFeedbackAsync(const TextFeedbackRequest& request, const TextFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, textFeedback(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::TextFeedbackOutcomeCallable GreenClient::textFeedbackCallable(const TextFeedbackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TextFeedbackOutcome()>>(
+			[this, request]()
+			{
+			return this->textFeedback(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::SearchOutcome GreenClient::search(const SearchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchOutcome(SearchResult(outcome.result()));
+	else
+		return SearchOutcome(outcome.error());
+}
+
+void GreenClient::searchAsync(const SearchRequest& request, const SearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, search(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::SearchOutcomeCallable GreenClient::searchCallable(const SearchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchOutcome()>>(
+			[this, request]()
+			{
+			return this->search(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::FileAsyncScanResultsOutcome GreenClient::fileAsyncScanResults(const FileAsyncScanResultsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FileAsyncScanResultsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FileAsyncScanResultsOutcome(FileAsyncScanResultsResult(outcome.result()));
+	else
+		return FileAsyncScanResultsOutcome(outcome.error());
+}
+
+void GreenClient::fileAsyncScanResultsAsync(const FileAsyncScanResultsRequest& request, const FileAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, fileAsyncScanResults(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::FileAsyncScanResultsOutcomeCallable GreenClient::fileAsyncScanResultsCallable(const FileAsyncScanResultsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FileAsyncScanResultsOutcome()>>(
+			[this, request]()
+			{
+			return this->fileAsyncScanResults(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::DeleteGroupsOutcome GreenClient::deleteGroups(const DeleteGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteGroupsOutcome(DeleteGroupsResult(outcome.result()));
+	else
+		return DeleteGroupsOutcome(outcome.error());
+}
+
+void GreenClient::deleteGroupsAsync(const DeleteGroupsRequest& request, const DeleteGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::DeleteGroupsOutcomeCallable GreenClient::deleteGroupsCallable(const DeleteGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::ImageAsyncScanOutcome GreenClient::imageAsyncScan(const ImageAsyncScanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImageAsyncScanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImageAsyncScanOutcome(ImageAsyncScanResult(outcome.result()));
+	else
+		return ImageAsyncScanOutcome(outcome.error());
+}
+
+void GreenClient::imageAsyncScanAsync(const ImageAsyncScanRequest& request, const ImageAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imageAsyncScan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::ImageAsyncScanOutcomeCallable GreenClient::imageAsyncScanCallable(const ImageAsyncScanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImageAsyncScanOutcome()>>(
+			[this, request]()
+			{
+			return this->imageAsyncScan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::VideoAsyncScanOutcome GreenClient::videoAsyncScan(const VideoAsyncScanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VideoAsyncScanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VideoAsyncScanOutcome(VideoAsyncScanResult(outcome.result()));
+	else
+		return VideoAsyncScanOutcome(outcome.error());
+}
+
+void GreenClient::videoAsyncScanAsync(const VideoAsyncScanRequest& request, const VideoAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, videoAsyncScan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::VideoAsyncScanOutcomeCallable GreenClient::videoAsyncScanCallable(const VideoAsyncScanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VideoAsyncScanOutcome()>>(
+			[this, request]()
+			{
+			return this->videoAsyncScan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::ImageAsyncScanResultsOutcome GreenClient::imageAsyncScanResults(const ImageAsyncScanResultsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImageAsyncScanResultsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImageAsyncScanResultsOutcome(ImageAsyncScanResultsResult(outcome.result()));
+	else
+		return ImageAsyncScanResultsOutcome(outcome.error());
+}
+
+void GreenClient::imageAsyncScanResultsAsync(const ImageAsyncScanResultsRequest& request, const ImageAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imageAsyncScanResults(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::ImageAsyncScanResultsOutcomeCallable GreenClient::imageAsyncScanResultsCallable(const ImageAsyncScanResultsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImageAsyncScanResultsOutcome()>>(
+			[this, request]()
+			{
+			return this->imageAsyncScanResults(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::VoiceAsyncScanResultsOutcome GreenClient::voiceAsyncScanResults(const VoiceAsyncScanResultsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VoiceAsyncScanResultsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VoiceAsyncScanResultsOutcome(VoiceAsyncScanResultsResult(outcome.result()));
+	else
+		return VoiceAsyncScanResultsOutcome(outcome.error());
+}
+
+void GreenClient::voiceAsyncScanResultsAsync(const VoiceAsyncScanResultsRequest& request, const VoiceAsyncScanResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, voiceAsyncScanResults(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::VoiceAsyncScanResultsOutcomeCallable GreenClient::voiceAsyncScanResultsCallable(const VoiceAsyncScanResultsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VoiceAsyncScanResultsOutcome()>>(
+			[this, request]()
+			{
+			return this->voiceAsyncScanResults(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::GetFacesOutcome GreenClient::getFaces(const GetFacesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetFacesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetFacesOutcome(GetFacesResult(outcome.result()));
+	else
+		return GetFacesOutcome(outcome.error());
+}
+
+void GreenClient::getFacesAsync(const GetFacesRequest& request, const GetFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getFaces(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::GetFacesOutcomeCallable GreenClient::getFacesCallable(const GetFacesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetFacesOutcome()>>(
+			[this, request]()
+			{
+			return this->getFaces(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::VoiceAsyncScanOutcome GreenClient::voiceAsyncScan(const VoiceAsyncScanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VoiceAsyncScanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VoiceAsyncScanOutcome(VoiceAsyncScanResult(outcome.result()));
+	else
+		return VoiceAsyncScanOutcome(outcome.error());
+}
+
+void GreenClient::voiceAsyncScanAsync(const VoiceAsyncScanRequest& request, const VoiceAsyncScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, voiceAsyncScan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::VoiceAsyncScanOutcomeCallable GreenClient::voiceAsyncScanCallable(const VoiceAsyncScanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VoiceAsyncScanOutcome()>>(
+			[this, request]()
+			{
+			return this->voiceAsyncScan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::GetGroupsOutcome GreenClient::getGroups(const GetGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetGroupsOutcome(GetGroupsResult(outcome.result()));
+	else
+		return GetGroupsOutcome(outcome.error());
+}
+
+void GreenClient::getGroupsAsync(const GetGroupsRequest& request, const GetGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::GetGroupsOutcomeCallable GreenClient::getGroupsCallable(const GetGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->getGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::TextScanOutcome GreenClient::textScan(const TextScanRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TextScanOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TextScanOutcome(TextScanResult(outcome.result()));
+	else
+		return TextScanOutcome(outcome.error());
+}
+
+void GreenClient::textScanAsync(const TextScanRequest& request, const TextScanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, textScan(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::TextScanOutcomeCallable GreenClient::textScanCallable(const TextScanRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TextScanOutcome()>>(
+			[this, request]()
+			{
+			return this->textScan(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::ImageScanFeedbackOutcome GreenClient::imageScanFeedback(const ImageScanFeedbackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImageScanFeedbackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImageScanFeedbackOutcome(ImageScanFeedbackResult(outcome.result()));
+	else
+		return ImageScanFeedbackOutcome(outcome.error());
+}
+
+void GreenClient::imageScanFeedbackAsync(const ImageScanFeedbackRequest& request, const ImageScanFeedbackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, imageScanFeedback(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::ImageScanFeedbackOutcomeCallable GreenClient::imageScanFeedbackCallable(const ImageScanFeedbackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImageScanFeedbackOutcome()>>(
+			[this, request]()
+			{
+			return this->imageScanFeedback(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::AddPersonOutcome GreenClient::addPerson(const AddPersonRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddPersonOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddPersonOutcome(AddPersonResult(outcome.result()));
+	else
+		return AddPersonOutcome(outcome.error());
+}
+
+void GreenClient::addPersonAsync(const AddPersonRequest& request, const AddPersonAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addPerson(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::AddPersonOutcomeCallable GreenClient::addPersonCallable(const AddPersonRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddPersonOutcome()>>(
+			[this, request]()
+			{
+			return this->addPerson(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+GreenClient::AddFacesOutcome GreenClient::addFaces(const AddFacesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddFacesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddFacesOutcome(AddFacesResult(outcome.result()));
+	else
+		return AddFacesOutcome(outcome.error());
+}
+
+void GreenClient::addFacesAsync(const AddFacesRequest& request, const AddFacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addFaces(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+GreenClient::AddFacesOutcomeCallable GreenClient::addFacesCallable(const AddFacesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddFacesOutcome()>>(
+			[this, request]()
+			{
+			return this->addFaces(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

green/src/model/AddFacesRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/AddFacesRequest.h>
+
+using AlibabaCloud::Green::Model::AddFacesRequest;
+
+AddFacesRequest::AddFacesRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+AddFacesRequest::~AddFacesRequest()
+{}
+
+std::string AddFacesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddFacesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AddFacesRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void AddFacesRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/AddFacesResult.cc

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

green/src/model/AddGroupsRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/AddGroupsRequest.h>
+
+using AlibabaCloud::Green::Model::AddGroupsRequest;
+
+AddGroupsRequest::AddGroupsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+AddGroupsRequest::~AddGroupsRequest()
+{}
+
+std::string AddGroupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddGroupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AddGroupsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void AddGroupsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/AddGroupsResult.cc

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

green/src/model/AddPersonRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/AddPersonRequest.h>
+
+using AlibabaCloud::Green::Model::AddPersonRequest;
+
+AddPersonRequest::AddPersonRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+AddPersonRequest::~AddPersonRequest()
+{}
+
+std::string AddPersonRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void AddPersonRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string AddPersonRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void AddPersonRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/AddPersonResult.cc

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

green/src/model/DeleteFacesRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/DeleteFacesRequest.h>
+
+using AlibabaCloud::Green::Model::DeleteFacesRequest;
+
+DeleteFacesRequest::DeleteFacesRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+DeleteFacesRequest::~DeleteFacesRequest()
+{}
+
+std::string DeleteFacesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteFacesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteFacesRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void DeleteFacesRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/DeleteFacesResult.cc

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

green/src/model/DeleteGroupsRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/DeleteGroupsRequest.h>
+
+using AlibabaCloud::Green::Model::DeleteGroupsRequest;
+
+DeleteGroupsRequest::DeleteGroupsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+DeleteGroupsRequest::~DeleteGroupsRequest()
+{}
+
+std::string DeleteGroupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteGroupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteGroupsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void DeleteGroupsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/DeleteGroupsResult.cc

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

green/src/model/DeletePersonRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/DeletePersonRequest.h>
+
+using AlibabaCloud::Green::Model::DeletePersonRequest;
+
+DeletePersonRequest::DeletePersonRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+DeletePersonRequest::~DeletePersonRequest()
+{}
+
+std::string DeletePersonRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeletePersonRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeletePersonRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void DeletePersonRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/DeletePersonResult.cc

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

green/src/model/FileAsyncScanRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/FileAsyncScanRequest.h>
+
+using AlibabaCloud::Green::Model::FileAsyncScanRequest;
+
+FileAsyncScanRequest::FileAsyncScanRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+FileAsyncScanRequest::~FileAsyncScanRequest()
+{}
+
+std::string FileAsyncScanRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void FileAsyncScanRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/FileAsyncScanResult.cc

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

green/src/model/FileAsyncScanResultsRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/FileAsyncScanResultsRequest.h>
+
+using AlibabaCloud::Green::Model::FileAsyncScanResultsRequest;
+
+FileAsyncScanResultsRequest::FileAsyncScanResultsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+FileAsyncScanResultsRequest::~FileAsyncScanResultsRequest()
+{}
+
+std::string FileAsyncScanResultsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void FileAsyncScanResultsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/FileAsyncScanResultsResult.cc

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

green/src/model/GetFacesRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/GetFacesRequest.h>
+
+using AlibabaCloud::Green::Model::GetFacesRequest;
+
+GetFacesRequest::GetFacesRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+GetFacesRequest::~GetFacesRequest()
+{}
+
+std::string GetFacesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetFacesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetFacesRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void GetFacesRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/GetFacesResult.cc

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

green/src/model/GetGroupsRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/GetGroupsRequest.h>
+
+using AlibabaCloud::Green::Model::GetGroupsRequest;
+
+GetGroupsRequest::GetGroupsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+GetGroupsRequest::~GetGroupsRequest()
+{}
+
+std::string GetGroupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetGroupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetGroupsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void GetGroupsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/GetGroupsResult.cc

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

green/src/model/GetPersonRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/GetPersonRequest.h>
+
+using AlibabaCloud::Green::Model::GetPersonRequest;
+
+GetPersonRequest::GetPersonRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+GetPersonRequest::~GetPersonRequest()
+{}
+
+std::string GetPersonRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetPersonRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetPersonRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void GetPersonRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/GetPersonResult.cc

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

green/src/model/GetPersonsRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/GetPersonsRequest.h>
+
+using AlibabaCloud::Green::Model::GetPersonsRequest;
+
+GetPersonsRequest::GetPersonsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+GetPersonsRequest::~GetPersonsRequest()
+{}
+
+std::string GetPersonsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetPersonsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetPersonsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void GetPersonsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/GetPersonsResult.cc

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

green/src/model/ImageAsyncScanRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/ImageAsyncScanRequest.h>
+
+using AlibabaCloud::Green::Model::ImageAsyncScanRequest;
+
+ImageAsyncScanRequest::ImageAsyncScanRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+ImageAsyncScanRequest::~ImageAsyncScanRequest()
+{}
+
+std::string ImageAsyncScanRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void ImageAsyncScanRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/ImageAsyncScanResult.cc

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

green/src/model/ImageAsyncScanResultsRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/ImageAsyncScanResultsRequest.h>
+
+using AlibabaCloud::Green::Model::ImageAsyncScanResultsRequest;
+
+ImageAsyncScanResultsRequest::ImageAsyncScanResultsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+ImageAsyncScanResultsRequest::~ImageAsyncScanResultsRequest()
+{}
+
+std::string ImageAsyncScanResultsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void ImageAsyncScanResultsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/ImageAsyncScanResultsResult.cc

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

green/src/model/ImageScanFeedbackRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/ImageScanFeedbackRequest.h>
+
+using AlibabaCloud::Green::Model::ImageScanFeedbackRequest;
+
+ImageScanFeedbackRequest::ImageScanFeedbackRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+ImageScanFeedbackRequest::~ImageScanFeedbackRequest()
+{}
+
+std::string ImageScanFeedbackRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void ImageScanFeedbackRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/ImageScanFeedbackResult.cc

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

green/src/model/ImageSyncScanRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/ImageSyncScanRequest.h>
+
+using AlibabaCloud::Green::Model::ImageSyncScanRequest;
+
+ImageSyncScanRequest::ImageSyncScanRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+ImageSyncScanRequest::~ImageSyncScanRequest()
+{}
+
+std::string ImageSyncScanRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void ImageSyncScanRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/ImageSyncScanResult.cc

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

green/src/model/SearchRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/SearchRequest.h>
+
+using AlibabaCloud::Green::Model::SearchRequest;
+
+SearchRequest::SearchRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+SearchRequest::~SearchRequest()
+{}
+
+std::string SearchRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SearchRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SearchRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void SearchRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/SearchResult.cc

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

green/src/model/SetPersonRequest.cc

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/green/model/SetPersonRequest.h>
+
+using AlibabaCloud::Green::Model::SetPersonRequest;
+
+SetPersonRequest::SetPersonRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+SetPersonRequest::~SetPersonRequest()
+{}
+
+std::string SetPersonRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetPersonRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SetPersonRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void SetPersonRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/SetPersonResult.cc

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

green/src/model/TextFeedbackRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/TextFeedbackRequest.h>
+
+using AlibabaCloud::Green::Model::TextFeedbackRequest;
+
+TextFeedbackRequest::TextFeedbackRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+TextFeedbackRequest::~TextFeedbackRequest()
+{}
+
+std::string TextFeedbackRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void TextFeedbackRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/TextFeedbackResult.cc

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

green/src/model/TextScanRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/TextScanRequest.h>
+
+using AlibabaCloud::Green::Model::TextScanRequest;
+
+TextScanRequest::TextScanRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+TextScanRequest::~TextScanRequest()
+{}
+
+std::string TextScanRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void TextScanRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/TextScanResult.cc

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

green/src/model/VideoAsyncScanRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/VideoAsyncScanRequest.h>
+
+using AlibabaCloud::Green::Model::VideoAsyncScanRequest;
+
+VideoAsyncScanRequest::VideoAsyncScanRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+VideoAsyncScanRequest::~VideoAsyncScanRequest()
+{}
+
+std::string VideoAsyncScanRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void VideoAsyncScanRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+

green/src/model/VideoAsyncScanResult.cc

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

green/src/model/VideoAsyncScanResultsRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * 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/green/model/VideoAsyncScanResultsRequest.h>
+
+using AlibabaCloud::Green::Model::VideoAsyncScanResultsRequest;
+
+VideoAsyncScanResultsRequest::VideoAsyncScanResultsRequest() :
+	RoaServiceRequest("green", "2017-08-25")
+{}
+
+VideoAsyncScanResultsRequest::~VideoAsyncScanResultsRequest()
+{}
+
+std::string VideoAsyncScanResultsRequest::getClientInfo()const
+{
+	return clientInfo_;
+}
+
+void VideoAsyncScanResultsRequest::setClientInfo(const std::string& clientInfo)
+{
+	clientInfo_ = clientInfo;
+	setParameter("ClientInfo", clientInfo);
+}
+