Add Api DetectIPCPedestrianOptimized.

CHANGELOG

@@ -1,6 +1,9 @@
 2020-09-17 Version: patch
 - Add Api DetectIPCPedestrianOptimized.
 
+2020-09-17 Version: patch
+- Add Api DetectIPCPedestrianOptimized.
+
 2020-09-17 Version: patch
 - GetTitleIntelligence add interface.
 

facebody/CMakeLists.txt

@@ -21,13 +21,161 @@ set(facebody_public_header
 	include/alibabacloud/facebody/FacebodyExport.h )
 
 set(facebody_public_header_model 
+	include/alibabacloud/facebody/model/AddFaceRequest.h
+	include/alibabacloud/facebody/model/AddFaceResult.h
+	include/alibabacloud/facebody/model/AddFaceEntityRequest.h
+	include/alibabacloud/facebody/model/AddFaceEntityResult.h
+	include/alibabacloud/facebody/model/BlurFaceRequest.h
+	include/alibabacloud/facebody/model/BlurFaceResult.h
+	include/alibabacloud/facebody/model/BodyPostureRequest.h
+	include/alibabacloud/facebody/model/BodyPostureResult.h
+	include/alibabacloud/facebody/model/CompareFaceRequest.h
+	include/alibabacloud/facebody/model/CompareFaceResult.h
+	include/alibabacloud/facebody/model/CreateFaceDbRequest.h
+	include/alibabacloud/facebody/model/CreateFaceDbResult.h
+	include/alibabacloud/facebody/model/DeleteFaceRequest.h
+	include/alibabacloud/facebody/model/DeleteFaceResult.h
+	include/alibabacloud/facebody/model/DeleteFaceDbRequest.h
+	include/alibabacloud/facebody/model/DeleteFaceDbResult.h
+	include/alibabacloud/facebody/model/DeleteFaceEntityRequest.h
+	include/alibabacloud/facebody/model/DeleteFaceEntityResult.h
+	include/alibabacloud/facebody/model/DetectBodyCountRequest.h
+	include/alibabacloud/facebody/model/DetectBodyCountResult.h
+	include/alibabacloud/facebody/model/DetectCelebrityRequest.h
+	include/alibabacloud/facebody/model/DetectCelebrityResult.h
+	include/alibabacloud/facebody/model/DetectChefCapRequest.h
+	include/alibabacloud/facebody/model/DetectChefCapResult.h
+	include/alibabacloud/facebody/model/DetectFaceRequest.h
+	include/alibabacloud/facebody/model/DetectFaceResult.h
+	include/alibabacloud/facebody/model/DetectIPCPedestrianRequest.h
+	include/alibabacloud/facebody/model/DetectIPCPedestrianResult.h
 	include/alibabacloud/facebody/model/DetectIPCPedestrianOptimizedRequest.h
-	include/alibabacloud/facebody/model/DetectIPCPedestrianOptimizedResult.h )
+	include/alibabacloud/facebody/model/DetectIPCPedestrianOptimizedResult.h
+	include/alibabacloud/facebody/model/DetectLivingFaceRequest.h
+	include/alibabacloud/facebody/model/DetectLivingFaceResult.h
+	include/alibabacloud/facebody/model/DetectMaskRequest.h
+	include/alibabacloud/facebody/model/DetectMaskResult.h
+	include/alibabacloud/facebody/model/DetectPedestrianRequest.h
+	include/alibabacloud/facebody/model/DetectPedestrianResult.h
+	include/alibabacloud/facebody/model/DetectVideoLivingFaceRequest.h
+	include/alibabacloud/facebody/model/DetectVideoLivingFaceResult.h
+	include/alibabacloud/facebody/model/EnhanceFaceRequest.h
+	include/alibabacloud/facebody/model/EnhanceFaceResult.h
+	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.h
+	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrResult.h
+	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.h
+	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeResult.h
+	include/alibabacloud/facebody/model/FaceBeautyRequest.h
+	include/alibabacloud/facebody/model/FaceBeautyResult.h
+	include/alibabacloud/facebody/model/FaceFilterRequest.h
+	include/alibabacloud/facebody/model/FaceFilterResult.h
+	include/alibabacloud/facebody/model/FaceMakeupRequest.h
+	include/alibabacloud/facebody/model/FaceMakeupResult.h
+	include/alibabacloud/facebody/model/FaceTidyupRequest.h
+	include/alibabacloud/facebody/model/FaceTidyupResult.h
+	include/alibabacloud/facebody/model/GetFaceEntityRequest.h
+	include/alibabacloud/facebody/model/GetFaceEntityResult.h
+	include/alibabacloud/facebody/model/HandPostureRequest.h
+	include/alibabacloud/facebody/model/HandPostureResult.h
+	include/alibabacloud/facebody/model/ListFaceDbsRequest.h
+	include/alibabacloud/facebody/model/ListFaceDbsResult.h
+	include/alibabacloud/facebody/model/ListFaceEntitiesRequest.h
+	include/alibabacloud/facebody/model/ListFaceEntitiesResult.h
+	include/alibabacloud/facebody/model/RecognizeActionRequest.h
+	include/alibabacloud/facebody/model/RecognizeActionResult.h
+	include/alibabacloud/facebody/model/RecognizeExpressionRequest.h
+	include/alibabacloud/facebody/model/RecognizeExpressionResult.h
+	include/alibabacloud/facebody/model/RecognizeFaceRequest.h
+	include/alibabacloud/facebody/model/RecognizeFaceResult.h
+	include/alibabacloud/facebody/model/RecognizePublicFaceRequest.h
+	include/alibabacloud/facebody/model/RecognizePublicFaceResult.h
+	include/alibabacloud/facebody/model/SearchFaceRequest.h
+	include/alibabacloud/facebody/model/SearchFaceResult.h
+	include/alibabacloud/facebody/model/SwapFacialFeaturesRequest.h
+	include/alibabacloud/facebody/model/SwapFacialFeaturesResult.h
+	include/alibabacloud/facebody/model/UpdateFaceEntityRequest.h
+	include/alibabacloud/facebody/model/UpdateFaceEntityResult.h
+	include/alibabacloud/facebody/model/VerifyFaceMaskRequest.h
+	include/alibabacloud/facebody/model/VerifyFaceMaskResult.h )
 
 set(facebody_src 
 	src/FacebodyClient.cc
+	src/model/AddFaceRequest.cc
+	src/model/AddFaceResult.cc
+	src/model/AddFaceEntityRequest.cc
+	src/model/AddFaceEntityResult.cc
+	src/model/BlurFaceRequest.cc
+	src/model/BlurFaceResult.cc
+	src/model/BodyPostureRequest.cc
+	src/model/BodyPostureResult.cc
+	src/model/CompareFaceRequest.cc
+	src/model/CompareFaceResult.cc
+	src/model/CreateFaceDbRequest.cc
+	src/model/CreateFaceDbResult.cc
+	src/model/DeleteFaceRequest.cc
+	src/model/DeleteFaceResult.cc
+	src/model/DeleteFaceDbRequest.cc
+	src/model/DeleteFaceDbResult.cc
+	src/model/DeleteFaceEntityRequest.cc
+	src/model/DeleteFaceEntityResult.cc
+	src/model/DetectBodyCountRequest.cc
+	src/model/DetectBodyCountResult.cc
+	src/model/DetectCelebrityRequest.cc
+	src/model/DetectCelebrityResult.cc
+	src/model/DetectChefCapRequest.cc
+	src/model/DetectChefCapResult.cc
+	src/model/DetectFaceRequest.cc
+	src/model/DetectFaceResult.cc
+	src/model/DetectIPCPedestrianRequest.cc
+	src/model/DetectIPCPedestrianResult.cc
 	src/model/DetectIPCPedestrianOptimizedRequest.cc
-	src/model/DetectIPCPedestrianOptimizedResult.cc )
+	src/model/DetectIPCPedestrianOptimizedResult.cc
+	src/model/DetectLivingFaceRequest.cc
+	src/model/DetectLivingFaceResult.cc
+	src/model/DetectMaskRequest.cc
+	src/model/DetectMaskResult.cc
+	src/model/DetectPedestrianRequest.cc
+	src/model/DetectPedestrianResult.cc
+	src/model/DetectVideoLivingFaceRequest.cc
+	src/model/DetectVideoLivingFaceResult.cc
+	src/model/EnhanceFaceRequest.cc
+	src/model/EnhanceFaceResult.cc
+	src/model/ExtractPedestrianFeatureAttrRequest.cc
+	src/model/ExtractPedestrianFeatureAttrResult.cc
+	src/model/ExtractPedestrianFeatureAttributeRequest.cc
+	src/model/ExtractPedestrianFeatureAttributeResult.cc
+	src/model/FaceBeautyRequest.cc
+	src/model/FaceBeautyResult.cc
+	src/model/FaceFilterRequest.cc
+	src/model/FaceFilterResult.cc
+	src/model/FaceMakeupRequest.cc
+	src/model/FaceMakeupResult.cc
+	src/model/FaceTidyupRequest.cc
+	src/model/FaceTidyupResult.cc
+	src/model/GetFaceEntityRequest.cc
+	src/model/GetFaceEntityResult.cc
+	src/model/HandPostureRequest.cc
+	src/model/HandPostureResult.cc
+	src/model/ListFaceDbsRequest.cc
+	src/model/ListFaceDbsResult.cc
+	src/model/ListFaceEntitiesRequest.cc
+	src/model/ListFaceEntitiesResult.cc
+	src/model/RecognizeActionRequest.cc
+	src/model/RecognizeActionResult.cc
+	src/model/RecognizeExpressionRequest.cc
+	src/model/RecognizeExpressionResult.cc
+	src/model/RecognizeFaceRequest.cc
+	src/model/RecognizeFaceResult.cc
+	src/model/RecognizePublicFaceRequest.cc
+	src/model/RecognizePublicFaceResult.cc
+	src/model/SearchFaceRequest.cc
+	src/model/SearchFaceResult.cc
+	src/model/SwapFacialFeaturesRequest.cc
+	src/model/SwapFacialFeaturesResult.cc
+	src/model/UpdateFaceEntityRequest.cc
+	src/model/UpdateFaceEntityResult.cc
+	src/model/VerifyFaceMaskRequest.cc
+	src/model/VerifyFaceMaskResult.cc )
 
 add_library(facebody ${LIB_TYPE}
 	${facebody_public_header}

facebody/include/alibabacloud/facebody/FacebodyClient.h

@@ -20,30 +20,326 @@
 #include <future>
 #include <alibabacloud/core/AsyncCallerContext.h>
 #include <alibabacloud/core/EndpointProvider.h>
-#include <alibabacloud/core/RoaServiceClient.h>
+#include <alibabacloud/core/RpcServiceClient.h>
 #include "FacebodyExport.h"
+#include "model/AddFaceRequest.h"
+#include "model/AddFaceResult.h"
+#include "model/AddFaceEntityRequest.h"
+#include "model/AddFaceEntityResult.h"
+#include "model/BlurFaceRequest.h"
+#include "model/BlurFaceResult.h"
+#include "model/BodyPostureRequest.h"
+#include "model/BodyPostureResult.h"
+#include "model/CompareFaceRequest.h"
+#include "model/CompareFaceResult.h"
+#include "model/CreateFaceDbRequest.h"
+#include "model/CreateFaceDbResult.h"
+#include "model/DeleteFaceRequest.h"
+#include "model/DeleteFaceResult.h"
+#include "model/DeleteFaceDbRequest.h"
+#include "model/DeleteFaceDbResult.h"
+#include "model/DeleteFaceEntityRequest.h"
+#include "model/DeleteFaceEntityResult.h"
+#include "model/DetectBodyCountRequest.h"
+#include "model/DetectBodyCountResult.h"
+#include "model/DetectCelebrityRequest.h"
+#include "model/DetectCelebrityResult.h"
+#include "model/DetectChefCapRequest.h"
+#include "model/DetectChefCapResult.h"
+#include "model/DetectFaceRequest.h"
+#include "model/DetectFaceResult.h"
+#include "model/DetectIPCPedestrianRequest.h"
+#include "model/DetectIPCPedestrianResult.h"
 #include "model/DetectIPCPedestrianOptimizedRequest.h"
 #include "model/DetectIPCPedestrianOptimizedResult.h"
+#include "model/DetectLivingFaceRequest.h"
+#include "model/DetectLivingFaceResult.h"
+#include "model/DetectMaskRequest.h"
+#include "model/DetectMaskResult.h"
+#include "model/DetectPedestrianRequest.h"
+#include "model/DetectPedestrianResult.h"
+#include "model/DetectVideoLivingFaceRequest.h"
+#include "model/DetectVideoLivingFaceResult.h"
+#include "model/EnhanceFaceRequest.h"
+#include "model/EnhanceFaceResult.h"
+#include "model/ExtractPedestrianFeatureAttrRequest.h"
+#include "model/ExtractPedestrianFeatureAttrResult.h"
+#include "model/ExtractPedestrianFeatureAttributeRequest.h"
+#include "model/ExtractPedestrianFeatureAttributeResult.h"
+#include "model/FaceBeautyRequest.h"
+#include "model/FaceBeautyResult.h"
+#include "model/FaceFilterRequest.h"
+#include "model/FaceFilterResult.h"
+#include "model/FaceMakeupRequest.h"
+#include "model/FaceMakeupResult.h"
+#include "model/FaceTidyupRequest.h"
+#include "model/FaceTidyupResult.h"
+#include "model/GetFaceEntityRequest.h"
+#include "model/GetFaceEntityResult.h"
+#include "model/HandPostureRequest.h"
+#include "model/HandPostureResult.h"
+#include "model/ListFaceDbsRequest.h"
+#include "model/ListFaceDbsResult.h"
+#include "model/ListFaceEntitiesRequest.h"
+#include "model/ListFaceEntitiesResult.h"
+#include "model/RecognizeActionRequest.h"
+#include "model/RecognizeActionResult.h"
+#include "model/RecognizeExpressionRequest.h"
+#include "model/RecognizeExpressionResult.h"
+#include "model/RecognizeFaceRequest.h"
+#include "model/RecognizeFaceResult.h"
+#include "model/RecognizePublicFaceRequest.h"
+#include "model/RecognizePublicFaceResult.h"
+#include "model/SearchFaceRequest.h"
+#include "model/SearchFaceResult.h"
+#include "model/SwapFacialFeaturesRequest.h"
+#include "model/SwapFacialFeaturesResult.h"
+#include "model/UpdateFaceEntityRequest.h"
+#include "model/UpdateFaceEntityResult.h"
+#include "model/VerifyFaceMaskRequest.h"
+#include "model/VerifyFaceMaskResult.h"
 
 
 namespace AlibabaCloud
 {
 	namespace Facebody
 	{
-		class ALIBABACLOUD_FACEBODY_EXPORT FacebodyClient : public RoaServiceClient
+		class ALIBABACLOUD_FACEBODY_EXPORT FacebodyClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AddFaceResult> AddFaceOutcome;
+			typedef std::future<AddFaceOutcome> AddFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::AddFaceRequest&, const AddFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFaceAsyncHandler;
+			typedef Outcome<Error, Model::AddFaceEntityResult> AddFaceEntityOutcome;
+			typedef std::future<AddFaceEntityOutcome> AddFaceEntityOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::AddFaceEntityRequest&, const AddFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFaceEntityAsyncHandler;
+			typedef Outcome<Error, Model::BlurFaceResult> BlurFaceOutcome;
+			typedef std::future<BlurFaceOutcome> BlurFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::BlurFaceRequest&, const BlurFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BlurFaceAsyncHandler;
+			typedef Outcome<Error, Model::BodyPostureResult> BodyPostureOutcome;
+			typedef std::future<BodyPostureOutcome> BodyPostureOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::BodyPostureRequest&, const BodyPostureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BodyPostureAsyncHandler;
+			typedef Outcome<Error, Model::CompareFaceResult> CompareFaceOutcome;
+			typedef std::future<CompareFaceOutcome> CompareFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::CompareFaceRequest&, const CompareFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompareFaceAsyncHandler;
+			typedef Outcome<Error, Model::CreateFaceDbResult> CreateFaceDbOutcome;
+			typedef std::future<CreateFaceDbOutcome> CreateFaceDbOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::CreateFaceDbRequest&, const CreateFaceDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFaceDbAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceResult> DeleteFaceOutcome;
+			typedef std::future<DeleteFaceOutcome> DeleteFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceRequest&, const DeleteFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceDbResult> DeleteFaceDbOutcome;
+			typedef std::future<DeleteFaceDbOutcome> DeleteFaceDbOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceDbRequest&, const DeleteFaceDbOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceDbAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceEntityResult> DeleteFaceEntityOutcome;
+			typedef std::future<DeleteFaceEntityOutcome> DeleteFaceEntityOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DeleteFaceEntityRequest&, const DeleteFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceEntityAsyncHandler;
+			typedef Outcome<Error, Model::DetectBodyCountResult> DetectBodyCountOutcome;
+			typedef std::future<DetectBodyCountOutcome> DetectBodyCountOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectBodyCountRequest&, const DetectBodyCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectBodyCountAsyncHandler;
+			typedef Outcome<Error, Model::DetectCelebrityResult> DetectCelebrityOutcome;
+			typedef std::future<DetectCelebrityOutcome> DetectCelebrityOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectCelebrityRequest&, const DetectCelebrityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectCelebrityAsyncHandler;
+			typedef Outcome<Error, Model::DetectChefCapResult> DetectChefCapOutcome;
+			typedef std::future<DetectChefCapOutcome> DetectChefCapOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectChefCapRequest&, const DetectChefCapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectChefCapAsyncHandler;
+			typedef Outcome<Error, Model::DetectFaceResult> DetectFaceOutcome;
+			typedef std::future<DetectFaceOutcome> DetectFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectFaceRequest&, const DetectFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectFaceAsyncHandler;
+			typedef Outcome<Error, Model::DetectIPCPedestrianResult> DetectIPCPedestrianOutcome;
+			typedef std::future<DetectIPCPedestrianOutcome> DetectIPCPedestrianOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectIPCPedestrianRequest&, const DetectIPCPedestrianOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectIPCPedestrianAsyncHandler;
 			typedef Outcome<Error, Model::DetectIPCPedestrianOptimizedResult> DetectIPCPedestrianOptimizedOutcome;
 			typedef std::future<DetectIPCPedestrianOptimizedOutcome> DetectIPCPedestrianOptimizedOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::DetectIPCPedestrianOptimizedRequest&, const DetectIPCPedestrianOptimizedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectIPCPedestrianOptimizedAsyncHandler;
+			typedef Outcome<Error, Model::DetectLivingFaceResult> DetectLivingFaceOutcome;
+			typedef std::future<DetectLivingFaceOutcome> DetectLivingFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectLivingFaceRequest&, const DetectLivingFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectLivingFaceAsyncHandler;
+			typedef Outcome<Error, Model::DetectMaskResult> DetectMaskOutcome;
+			typedef std::future<DetectMaskOutcome> DetectMaskOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectMaskRequest&, const DetectMaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectMaskAsyncHandler;
+			typedef Outcome<Error, Model::DetectPedestrianResult> DetectPedestrianOutcome;
+			typedef std::future<DetectPedestrianOutcome> DetectPedestrianOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectPedestrianRequest&, const DetectPedestrianOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectPedestrianAsyncHandler;
+			typedef Outcome<Error, Model::DetectVideoLivingFaceResult> DetectVideoLivingFaceOutcome;
+			typedef std::future<DetectVideoLivingFaceOutcome> DetectVideoLivingFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectVideoLivingFaceRequest&, const DetectVideoLivingFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectVideoLivingFaceAsyncHandler;
+			typedef Outcome<Error, Model::EnhanceFaceResult> EnhanceFaceOutcome;
+			typedef std::future<EnhanceFaceOutcome> EnhanceFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::EnhanceFaceRequest&, const EnhanceFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnhanceFaceAsyncHandler;
+			typedef Outcome<Error, Model::ExtractPedestrianFeatureAttrResult> ExtractPedestrianFeatureAttrOutcome;
+			typedef std::future<ExtractPedestrianFeatureAttrOutcome> ExtractPedestrianFeatureAttrOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::ExtractPedestrianFeatureAttrRequest&, const ExtractPedestrianFeatureAttrOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPedestrianFeatureAttrAsyncHandler;
+			typedef Outcome<Error, Model::ExtractPedestrianFeatureAttributeResult> ExtractPedestrianFeatureAttributeOutcome;
+			typedef std::future<ExtractPedestrianFeatureAttributeOutcome> ExtractPedestrianFeatureAttributeOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::ExtractPedestrianFeatureAttributeRequest&, const ExtractPedestrianFeatureAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPedestrianFeatureAttributeAsyncHandler;
+			typedef Outcome<Error, Model::FaceBeautyResult> FaceBeautyOutcome;
+			typedef std::future<FaceBeautyOutcome> FaceBeautyOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::FaceBeautyRequest&, const FaceBeautyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceBeautyAsyncHandler;
+			typedef Outcome<Error, Model::FaceFilterResult> FaceFilterOutcome;
+			typedef std::future<FaceFilterOutcome> FaceFilterOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::FaceFilterRequest&, const FaceFilterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceFilterAsyncHandler;
+			typedef Outcome<Error, Model::FaceMakeupResult> FaceMakeupOutcome;
+			typedef std::future<FaceMakeupOutcome> FaceMakeupOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::FaceMakeupRequest&, const FaceMakeupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceMakeupAsyncHandler;
+			typedef Outcome<Error, Model::FaceTidyupResult> FaceTidyupOutcome;
+			typedef std::future<FaceTidyupOutcome> FaceTidyupOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::FaceTidyupRequest&, const FaceTidyupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FaceTidyupAsyncHandler;
+			typedef Outcome<Error, Model::GetFaceEntityResult> GetFaceEntityOutcome;
+			typedef std::future<GetFaceEntityOutcome> GetFaceEntityOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::GetFaceEntityRequest&, const GetFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceEntityAsyncHandler;
+			typedef Outcome<Error, Model::HandPostureResult> HandPostureOutcome;
+			typedef std::future<HandPostureOutcome> HandPostureOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::HandPostureRequest&, const HandPostureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HandPostureAsyncHandler;
+			typedef Outcome<Error, Model::ListFaceDbsResult> ListFaceDbsOutcome;
+			typedef std::future<ListFaceDbsOutcome> ListFaceDbsOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::ListFaceDbsRequest&, const ListFaceDbsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceDbsAsyncHandler;
+			typedef Outcome<Error, Model::ListFaceEntitiesResult> ListFaceEntitiesOutcome;
+			typedef std::future<ListFaceEntitiesOutcome> ListFaceEntitiesOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::ListFaceEntitiesRequest&, const ListFaceEntitiesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFaceEntitiesAsyncHandler;
+			typedef Outcome<Error, Model::RecognizeActionResult> RecognizeActionOutcome;
+			typedef std::future<RecognizeActionOutcome> RecognizeActionOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::RecognizeActionRequest&, const RecognizeActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeActionAsyncHandler;
+			typedef Outcome<Error, Model::RecognizeExpressionResult> RecognizeExpressionOutcome;
+			typedef std::future<RecognizeExpressionOutcome> RecognizeExpressionOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::RecognizeExpressionRequest&, const RecognizeExpressionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeExpressionAsyncHandler;
+			typedef Outcome<Error, Model::RecognizeFaceResult> RecognizeFaceOutcome;
+			typedef std::future<RecognizeFaceOutcome> RecognizeFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::RecognizeFaceRequest&, const RecognizeFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeFaceAsyncHandler;
+			typedef Outcome<Error, Model::RecognizePublicFaceResult> RecognizePublicFaceOutcome;
+			typedef std::future<RecognizePublicFaceOutcome> RecognizePublicFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::RecognizePublicFaceRequest&, const RecognizePublicFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePublicFaceAsyncHandler;
+			typedef Outcome<Error, Model::SearchFaceResult> SearchFaceOutcome;
+			typedef std::future<SearchFaceOutcome> SearchFaceOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::SearchFaceRequest&, const SearchFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchFaceAsyncHandler;
+			typedef Outcome<Error, Model::SwapFacialFeaturesResult> SwapFacialFeaturesOutcome;
+			typedef std::future<SwapFacialFeaturesOutcome> SwapFacialFeaturesOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::SwapFacialFeaturesRequest&, const SwapFacialFeaturesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwapFacialFeaturesAsyncHandler;
+			typedef Outcome<Error, Model::UpdateFaceEntityResult> UpdateFaceEntityOutcome;
+			typedef std::future<UpdateFaceEntityOutcome> UpdateFaceEntityOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::UpdateFaceEntityRequest&, const UpdateFaceEntityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFaceEntityAsyncHandler;
+			typedef Outcome<Error, Model::VerifyFaceMaskResult> VerifyFaceMaskOutcome;
+			typedef std::future<VerifyFaceMaskOutcome> VerifyFaceMaskOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::VerifyFaceMaskRequest&, const VerifyFaceMaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyFaceMaskAsyncHandler;
 
 			FacebodyClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			FacebodyClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			FacebodyClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~FacebodyClient();
+			AddFaceOutcome addFace(const Model::AddFaceRequest &request)const;
+			void addFaceAsync(const Model::AddFaceRequest& request, const AddFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddFaceOutcomeCallable addFaceCallable(const Model::AddFaceRequest& request) const;
+			AddFaceEntityOutcome addFaceEntity(const Model::AddFaceEntityRequest &request)const;
+			void addFaceEntityAsync(const Model::AddFaceEntityRequest& request, const AddFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddFaceEntityOutcomeCallable addFaceEntityCallable(const Model::AddFaceEntityRequest& request) const;
+			BlurFaceOutcome blurFace(const Model::BlurFaceRequest &request)const;
+			void blurFaceAsync(const Model::BlurFaceRequest& request, const BlurFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BlurFaceOutcomeCallable blurFaceCallable(const Model::BlurFaceRequest& request) const;
+			BodyPostureOutcome bodyPosture(const Model::BodyPostureRequest &request)const;
+			void bodyPostureAsync(const Model::BodyPostureRequest& request, const BodyPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BodyPostureOutcomeCallable bodyPostureCallable(const Model::BodyPostureRequest& request) const;
+			CompareFaceOutcome compareFace(const Model::CompareFaceRequest &request)const;
+			void compareFaceAsync(const Model::CompareFaceRequest& request, const CompareFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CompareFaceOutcomeCallable compareFaceCallable(const Model::CompareFaceRequest& request) const;
+			CreateFaceDbOutcome createFaceDb(const Model::CreateFaceDbRequest &request)const;
+			void createFaceDbAsync(const Model::CreateFaceDbRequest& request, const CreateFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFaceDbOutcomeCallable createFaceDbCallable(const Model::CreateFaceDbRequest& request) const;
+			DeleteFaceOutcome deleteFace(const Model::DeleteFaceRequest &request)const;
+			void deleteFaceAsync(const Model::DeleteFaceRequest& request, const DeleteFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceOutcomeCallable deleteFaceCallable(const Model::DeleteFaceRequest& request) const;
+			DeleteFaceDbOutcome deleteFaceDb(const Model::DeleteFaceDbRequest &request)const;
+			void deleteFaceDbAsync(const Model::DeleteFaceDbRequest& request, const DeleteFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceDbOutcomeCallable deleteFaceDbCallable(const Model::DeleteFaceDbRequest& request) const;
+			DeleteFaceEntityOutcome deleteFaceEntity(const Model::DeleteFaceEntityRequest &request)const;
+			void deleteFaceEntityAsync(const Model::DeleteFaceEntityRequest& request, const DeleteFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceEntityOutcomeCallable deleteFaceEntityCallable(const Model::DeleteFaceEntityRequest& request) const;
+			DetectBodyCountOutcome detectBodyCount(const Model::DetectBodyCountRequest &request)const;
+			void detectBodyCountAsync(const Model::DetectBodyCountRequest& request, const DetectBodyCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectBodyCountOutcomeCallable detectBodyCountCallable(const Model::DetectBodyCountRequest& request) const;
+			DetectCelebrityOutcome detectCelebrity(const Model::DetectCelebrityRequest &request)const;
+			void detectCelebrityAsync(const Model::DetectCelebrityRequest& request, const DetectCelebrityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectCelebrityOutcomeCallable detectCelebrityCallable(const Model::DetectCelebrityRequest& request) const;
+			DetectChefCapOutcome detectChefCap(const Model::DetectChefCapRequest &request)const;
+			void detectChefCapAsync(const Model::DetectChefCapRequest& request, const DetectChefCapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectChefCapOutcomeCallable detectChefCapCallable(const Model::DetectChefCapRequest& request) const;
+			DetectFaceOutcome detectFace(const Model::DetectFaceRequest &request)const;
+			void detectFaceAsync(const Model::DetectFaceRequest& request, const DetectFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectFaceOutcomeCallable detectFaceCallable(const Model::DetectFaceRequest& request) const;
+			DetectIPCPedestrianOutcome detectIPCPedestrian(const Model::DetectIPCPedestrianRequest &request)const;
+			void detectIPCPedestrianAsync(const Model::DetectIPCPedestrianRequest& request, const DetectIPCPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectIPCPedestrianOutcomeCallable detectIPCPedestrianCallable(const Model::DetectIPCPedestrianRequest& request) const;
 			DetectIPCPedestrianOptimizedOutcome detectIPCPedestrianOptimized(const Model::DetectIPCPedestrianOptimizedRequest &request)const;
 			void detectIPCPedestrianOptimizedAsync(const Model::DetectIPCPedestrianOptimizedRequest& request, const DetectIPCPedestrianOptimizedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectIPCPedestrianOptimizedOutcomeCallable detectIPCPedestrianOptimizedCallable(const Model::DetectIPCPedestrianOptimizedRequest& request) const;
+			DetectLivingFaceOutcome detectLivingFace(const Model::DetectLivingFaceRequest &request)const;
+			void detectLivingFaceAsync(const Model::DetectLivingFaceRequest& request, const DetectLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectLivingFaceOutcomeCallable detectLivingFaceCallable(const Model::DetectLivingFaceRequest& request) const;
+			DetectMaskOutcome detectMask(const Model::DetectMaskRequest &request)const;
+			void detectMaskAsync(const Model::DetectMaskRequest& request, const DetectMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectMaskOutcomeCallable detectMaskCallable(const Model::DetectMaskRequest& request) const;
+			DetectPedestrianOutcome detectPedestrian(const Model::DetectPedestrianRequest &request)const;
+			void detectPedestrianAsync(const Model::DetectPedestrianRequest& request, const DetectPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectPedestrianOutcomeCallable detectPedestrianCallable(const Model::DetectPedestrianRequest& request) const;
+			DetectVideoLivingFaceOutcome detectVideoLivingFace(const Model::DetectVideoLivingFaceRequest &request)const;
+			void detectVideoLivingFaceAsync(const Model::DetectVideoLivingFaceRequest& request, const DetectVideoLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectVideoLivingFaceOutcomeCallable detectVideoLivingFaceCallable(const Model::DetectVideoLivingFaceRequest& request) const;
+			EnhanceFaceOutcome enhanceFace(const Model::EnhanceFaceRequest &request)const;
+			void enhanceFaceAsync(const Model::EnhanceFaceRequest& request, const EnhanceFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnhanceFaceOutcomeCallable enhanceFaceCallable(const Model::EnhanceFaceRequest& request) const;
+			ExtractPedestrianFeatureAttrOutcome extractPedestrianFeatureAttr(const Model::ExtractPedestrianFeatureAttrRequest &request)const;
+			void extractPedestrianFeatureAttrAsync(const Model::ExtractPedestrianFeatureAttrRequest& request, const ExtractPedestrianFeatureAttrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExtractPedestrianFeatureAttrOutcomeCallable extractPedestrianFeatureAttrCallable(const Model::ExtractPedestrianFeatureAttrRequest& request) const;
+			ExtractPedestrianFeatureAttributeOutcome extractPedestrianFeatureAttribute(const Model::ExtractPedestrianFeatureAttributeRequest &request)const;
+			void extractPedestrianFeatureAttributeAsync(const Model::ExtractPedestrianFeatureAttributeRequest& request, const ExtractPedestrianFeatureAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExtractPedestrianFeatureAttributeOutcomeCallable extractPedestrianFeatureAttributeCallable(const Model::ExtractPedestrianFeatureAttributeRequest& request) const;
+			FaceBeautyOutcome faceBeauty(const Model::FaceBeautyRequest &request)const;
+			void faceBeautyAsync(const Model::FaceBeautyRequest& request, const FaceBeautyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FaceBeautyOutcomeCallable faceBeautyCallable(const Model::FaceBeautyRequest& request) const;
+			FaceFilterOutcome faceFilter(const Model::FaceFilterRequest &request)const;
+			void faceFilterAsync(const Model::FaceFilterRequest& request, const FaceFilterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FaceFilterOutcomeCallable faceFilterCallable(const Model::FaceFilterRequest& request) const;
+			FaceMakeupOutcome faceMakeup(const Model::FaceMakeupRequest &request)const;
+			void faceMakeupAsync(const Model::FaceMakeupRequest& request, const FaceMakeupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FaceMakeupOutcomeCallable faceMakeupCallable(const Model::FaceMakeupRequest& request) const;
+			FaceTidyupOutcome faceTidyup(const Model::FaceTidyupRequest &request)const;
+			void faceTidyupAsync(const Model::FaceTidyupRequest& request, const FaceTidyupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FaceTidyupOutcomeCallable faceTidyupCallable(const Model::FaceTidyupRequest& request) const;
+			GetFaceEntityOutcome getFaceEntity(const Model::GetFaceEntityRequest &request)const;
+			void getFaceEntityAsync(const Model::GetFaceEntityRequest& request, const GetFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFaceEntityOutcomeCallable getFaceEntityCallable(const Model::GetFaceEntityRequest& request) const;
+			HandPostureOutcome handPosture(const Model::HandPostureRequest &request)const;
+			void handPostureAsync(const Model::HandPostureRequest& request, const HandPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			HandPostureOutcomeCallable handPostureCallable(const Model::HandPostureRequest& request) const;
+			ListFaceDbsOutcome listFaceDbs(const Model::ListFaceDbsRequest &request)const;
+			void listFaceDbsAsync(const Model::ListFaceDbsRequest& request, const ListFaceDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFaceDbsOutcomeCallable listFaceDbsCallable(const Model::ListFaceDbsRequest& request) const;
+			ListFaceEntitiesOutcome listFaceEntities(const Model::ListFaceEntitiesRequest &request)const;
+			void listFaceEntitiesAsync(const Model::ListFaceEntitiesRequest& request, const ListFaceEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFaceEntitiesOutcomeCallable listFaceEntitiesCallable(const Model::ListFaceEntitiesRequest& request) const;
+			RecognizeActionOutcome recognizeAction(const Model::RecognizeActionRequest &request)const;
+			void recognizeActionAsync(const Model::RecognizeActionRequest& request, const RecognizeActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecognizeActionOutcomeCallable recognizeActionCallable(const Model::RecognizeActionRequest& request) const;
+			RecognizeExpressionOutcome recognizeExpression(const Model::RecognizeExpressionRequest &request)const;
+			void recognizeExpressionAsync(const Model::RecognizeExpressionRequest& request, const RecognizeExpressionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecognizeExpressionOutcomeCallable recognizeExpressionCallable(const Model::RecognizeExpressionRequest& request) const;
+			RecognizeFaceOutcome recognizeFace(const Model::RecognizeFaceRequest &request)const;
+			void recognizeFaceAsync(const Model::RecognizeFaceRequest& request, const RecognizeFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecognizeFaceOutcomeCallable recognizeFaceCallable(const Model::RecognizeFaceRequest& request) const;
+			RecognizePublicFaceOutcome recognizePublicFace(const Model::RecognizePublicFaceRequest &request)const;
+			void recognizePublicFaceAsync(const Model::RecognizePublicFaceRequest& request, const RecognizePublicFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecognizePublicFaceOutcomeCallable recognizePublicFaceCallable(const Model::RecognizePublicFaceRequest& request) const;
+			SearchFaceOutcome searchFace(const Model::SearchFaceRequest &request)const;
+			void searchFaceAsync(const Model::SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchFaceOutcomeCallable searchFaceCallable(const Model::SearchFaceRequest& request) const;
+			SwapFacialFeaturesOutcome swapFacialFeatures(const Model::SwapFacialFeaturesRequest &request)const;
+			void swapFacialFeaturesAsync(const Model::SwapFacialFeaturesRequest& request, const SwapFacialFeaturesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SwapFacialFeaturesOutcomeCallable swapFacialFeaturesCallable(const Model::SwapFacialFeaturesRequest& request) const;
+			UpdateFaceEntityOutcome updateFaceEntity(const Model::UpdateFaceEntityRequest &request)const;
+			void updateFaceEntityAsync(const Model::UpdateFaceEntityRequest& request, const UpdateFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateFaceEntityOutcomeCallable updateFaceEntityCallable(const Model::UpdateFaceEntityRequest& request) const;
+			VerifyFaceMaskOutcome verifyFaceMask(const Model::VerifyFaceMaskRequest &request)const;
+			void verifyFaceMaskAsync(const Model::VerifyFaceMaskRequest& request, const VerifyFaceMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VerifyFaceMaskOutcomeCallable verifyFaceMaskCallable(const Model::VerifyFaceMaskRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

facebody/include/alibabacloud/facebody/model/AddFaceEntityRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT AddFaceEntityRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddFaceEntityRequest();
+				~AddFaceEntityRequest();
+
+				std::string getEntityId()const;
+				void setEntityId(const std::string& entityId);
+				std::string getLabels()const;
+				void setLabels(const std::string& labels);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string entityId_;
+				std::string labels_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYREQUEST_H_

facebody/include/alibabacloud/facebody/model/AddFaceEntityResult.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_FACEBODY_MODEL_ADDFACEENTITYRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT AddFaceEntityResult : public ServiceResult
+			{
+			public:
+
+
+				AddFaceEntityResult();
+				explicit AddFaceEntityResult(const std::string &payload);
+				~AddFaceEntityResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACEENTITYRESULT_H_

facebody/include/alibabacloud/facebody/model/AddFaceRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_ADDFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_ADDFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT AddFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddFaceRequest();
+				~AddFaceRequest();
+
+				std::string getEntityId()const;
+				void setEntityId(const std::string& entityId);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				std::string getExtraData()const;
+				void setExtraData(const std::string& extraData);
+
+            private:
+				std::string entityId_;
+				std::string dbName_;
+				std::string imageUrl_;
+				std::string extraData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_ADDFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/AddFaceResult.h

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

facebody/include/alibabacloud/facebody/model/BlurFaceRequest.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_FACEBODY_MODEL_BLURFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_BLURFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT BlurFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				BlurFaceRequest();
+				~BlurFaceRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_BLURFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/BlurFaceResult.h

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

facebody/include/alibabacloud/facebody/model/BodyPostureRequest.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_FACEBODY_MODEL_BODYPOSTUREREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTUREREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT BodyPostureRequest : public RpcServiceRequest
+			{
+
+			public:
+				BodyPostureRequest();
+				~BodyPostureRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTUREREQUEST_H_

facebody/include/alibabacloud/facebody/model/BodyPostureResult.h

@@ -0,0 +1,80 @@
+/*
+ * 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_FACEBODY_MODEL_BODYPOSTURERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTURERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT BodyPostureResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct MetaObject
+					{
+						int height;
+						int width;
+					};
+					struct Output
+					{
+						struct Result
+						{
+							struct Body
+							{
+								struct Position
+								{
+									std::vector<std::string> points;
+								};
+								float confident;
+								std::vector<Body::Position> positions;
+								std::string label;
+							};
+							std::vector<Result::Body> bodies;
+						};
+						std::vector<Output::Result> results;
+						int humanCount;
+					};
+					MetaObject metaObject;
+					std::vector<Output> outputs;
+				};
+
+
+				BodyPostureResult();
+				explicit BodyPostureResult(const std::string &payload);
+				~BodyPostureResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_BODYPOSTURERESULT_H_

facebody/include/alibabacloud/facebody/model/CompareFaceRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT CompareFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				CompareFaceRequest();
+				~CompareFaceRequest();
+
+				int getImageType()const;
+				void setImageType(int imageType);
+				std::string getImageURLB()const;
+				void setImageURLB(const std::string& imageURLB);
+				std::string getImageURLA()const;
+				void setImageURLA(const std::string& imageURLA);
+
+            private:
+				int imageType_;
+				std::string imageURLB_;
+				std::string imageURLA_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_COMPAREFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/CompareFaceResult.h

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

facebody/include/alibabacloud/facebody/model/CreateFaceDbRequest.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_FACEBODY_MODEL_CREATEFACEDBREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT CreateFaceDbRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateFaceDbRequest();
+				~CreateFaceDbRequest();
+
+				std::string getName()const;
+				void setName(const std::string& name);
+
+            private:
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBREQUEST_H_

facebody/include/alibabacloud/facebody/model/CreateFaceDbResult.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_FACEBODY_MODEL_CREATEFACEDBRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT CreateFaceDbResult : public ServiceResult
+			{
+			public:
+
+
+				CreateFaceDbResult();
+				explicit CreateFaceDbResult(const std::string &payload);
+				~CreateFaceDbResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_CREATEFACEDBRESULT_H_

facebody/include/alibabacloud/facebody/model/DeleteFaceDbRequest.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_FACEBODY_MODEL_DELETEFACEDBREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceDbRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteFaceDbRequest();
+				~DeleteFaceDbRequest();
+
+				std::string getName()const;
+				void setName(const std::string& name);
+
+            private:
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBREQUEST_H_

facebody/include/alibabacloud/facebody/model/DeleteFaceDbResult.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_FACEBODY_MODEL_DELETEFACEDBRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceDbResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFaceDbResult();
+				explicit DeleteFaceDbResult(const std::string &payload);
+				~DeleteFaceDbResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEDBRESULT_H_

facebody/include/alibabacloud/facebody/model/DeleteFaceEntityRequest.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_FACEBODY_MODEL_DELETEFACEENTITYREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceEntityRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteFaceEntityRequest();
+				~DeleteFaceEntityRequest();
+
+				std::string getEntityId()const;
+				void setEntityId(const std::string& entityId);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string entityId_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYREQUEST_H_

facebody/include/alibabacloud/facebody/model/DeleteFaceEntityResult.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_FACEBODY_MODEL_DELETEFACEENTITYRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceEntityResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFaceEntityResult();
+				explicit DeleteFaceEntityResult(const std::string &payload);
+				~DeleteFaceEntityResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEENTITYRESULT_H_

facebody/include/alibabacloud/facebody/model/DeleteFaceRequest.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_FACEBODY_MODEL_DELETEFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteFaceRequest();
+				~DeleteFaceRequest();
+
+				std::string getFaceId()const;
+				void setFaceId(const std::string& faceId);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string faceId_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/DeleteFaceResult.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_FACEBODY_MODEL_DELETEFACERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DELETEFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DeleteFaceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFaceResult();
+				explicit DeleteFaceResult(const std::string &payload);
+				~DeleteFaceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DELETEFACERESULT_H_

facebody/include/alibabacloud/facebody/model/DetectBodyCountRequest.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_FACEBODY_MODEL_DETECTBODYCOUNTREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTBODYCOUNTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectBodyCountRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectBodyCountRequest();
+				~DetectBodyCountRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTBODYCOUNTREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectBodyCountResult.h

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

facebody/include/alibabacloud/facebody/model/DetectCelebrityRequest.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_FACEBODY_MODEL_DETECTCELEBRITYREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCELEBRITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectCelebrityRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectCelebrityRequest();
+				~DetectCelebrityRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCELEBRITYREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectCelebrityResult.h

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

facebody/include/alibabacloud/facebody/model/DetectChefCapRequest.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_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectChefCapRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectChefCapRequest();
+				~DetectChefCapRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectChefCapResult.h

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

facebody/include/alibabacloud/facebody/model/DetectFaceRequest.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_FACEBODY_MODEL_DETECTFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectFaceRequest();
+				~DetectFaceRequest();
+
+				int getImageType()const;
+				void setImageType(int imageType);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				int imageType_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectFaceResult.h

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

facebody/include/alibabacloud/facebody/model/DetectIPCPedestrianRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectIPCPedestrianRequest : public RpcServiceRequest
+			{
+			public:
+				struct URLList
+				{
+					std::string dataId;
+					std::string imageURL;
+				};
+
+			public:
+				DetectIPCPedestrianRequest();
+				~DetectIPCPedestrianRequest();
+
+				std::string getImageData()const;
+				void setImageData(const std::string& imageData);
+				std::vector<URLList> getURLList()const;
+				void setURLList(const std::vector<URLList>& uRLList);
+				bool getContinueOnError()const;
+				void setContinueOnError(bool continueOnError);
+				int getWidth()const;
+				void setWidth(int width);
+				int getHeight()const;
+				void setHeight(int height);
+
+            private:
+				std::string imageData_;
+				std::vector<URLList> uRLList_;
+				bool continueOnError_;
+				int width_;
+				int height_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectIPCPedestrianResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_FACEBODY_MODEL_DETECTIPCPEDESTRIANRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectIPCPedestrianResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ImageInfoListItem
+					{
+						struct Element
+						{
+							float score;
+							std::vector<std::string> boxes;
+						};
+						std::string dataId;
+						std::string errorCode;
+						std::vector<ImageInfoListItem::Element> elements;
+						std::string errorMessage;
+					};
+					std::vector<ImageInfoListItem> imageInfoList;
+				};
+
+
+				DetectIPCPedestrianResult();
+				explicit DetectIPCPedestrianResult(const std::string &payload);
+				~DetectIPCPedestrianResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTIPCPEDESTRIANRESULT_H_

facebody/include/alibabacloud/facebody/model/DetectLivingFaceRequest.h

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

facebody/include/alibabacloud/facebody/model/DetectLivingFaceResult.h

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

facebody/include/alibabacloud/facebody/model/DetectMaskRequest.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_FACEBODY_MODEL_DETECTMASKREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTMASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectMaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectMaskRequest();
+				~DetectMaskRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTMASKREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectMaskResult.h

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

facebody/include/alibabacloud/facebody/model/DetectPedestrianRequest.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_FACEBODY_MODEL_DETECTPEDESTRIANREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTPEDESTRIANREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectPedestrianRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectPedestrianRequest();
+				~DetectPedestrianRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTPEDESTRIANREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectPedestrianResult.h

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

facebody/include/alibabacloud/facebody/model/DetectVideoLivingFaceRequest.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_FACEBODY_MODEL_DETECTVIDEOLIVINGFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTVIDEOLIVINGFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectVideoLivingFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectVideoLivingFaceRequest();
+				~DetectVideoLivingFaceRequest();
+
+				std::string getVideoUrl()const;
+				void setVideoUrl(const std::string& videoUrl);
+
+            private:
+				std::string videoUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTVIDEOLIVINGFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectVideoLivingFaceResult.h

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

facebody/include/alibabacloud/facebody/model/EnhanceFaceRequest.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_FACEBODY_MODEL_ENHANCEFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT EnhanceFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnhanceFaceRequest();
+				~EnhanceFaceRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_ENHANCEFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/EnhanceFaceResult.h

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

facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.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_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttrRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractPedestrianFeatureAttrRequest();
+				~ExtractPedestrianFeatureAttrRequest();
+
+				std::string getMode()const;
+				void setMode(const std::string& mode);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string mode_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_

facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttrResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string hair;
+					std::string upperType;
+					float upperTypeScore;
+					float qualityScore;
+					std::string lowerColor;
+					std::string gender;
+					std::string feature;
+					float upperColorScore;
+					float lowerColorScore;
+					float genderScore;
+					std::string objType;
+					float lowerTypeScore;
+					float hairScore;
+					std::string upperColor;
+					std::string lowerType;
+					float ageScore;
+					float objTypeScore;
+					std::string age;
+				};
+
+
+				ExtractPedestrianFeatureAttrResult();
+				explicit ExtractPedestrianFeatureAttrResult(const std::string &payload);
+				~ExtractPedestrianFeatureAttrResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_

facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.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_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttributeRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractPedestrianFeatureAttributeRequest();
+				~ExtractPedestrianFeatureAttributeRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTEREQUEST_H_

facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttributeResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string hair;
+					std::string upperType;
+					float upperTypeScore;
+					float qualityScore;
+					std::string lowerColor;
+					std::string gender;
+					std::string feature;
+					float upperColorScore;
+					float lowerColorScore;
+					float genderScore;
+					std::string objType;
+					float lowerTypeScore;
+					float hairScore;
+					std::string upperColor;
+					std::string lowerType;
+					float ageScore;
+					float objTypeScore;
+					std::string age;
+				};
+
+
+				ExtractPedestrianFeatureAttributeResult();
+				explicit ExtractPedestrianFeatureAttributeResult(const std::string &payload);
+				~ExtractPedestrianFeatureAttributeResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRIBUTERESULT_H_

facebody/include/alibabacloud/facebody/model/FaceBeautyRequest.h

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

facebody/include/alibabacloud/facebody/model/FaceBeautyResult.h

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

facebody/include/alibabacloud/facebody/model/FaceFilterRequest.h

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

facebody/include/alibabacloud/facebody/model/FaceFilterResult.h

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

facebody/include/alibabacloud/facebody/model/FaceMakeupRequest.h

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

facebody/include/alibabacloud/facebody/model/FaceMakeupResult.h

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

facebody/include/alibabacloud/facebody/model/FaceTidyupRequest.h

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

facebody/include/alibabacloud/facebody/model/FaceTidyupResult.h

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

facebody/include/alibabacloud/facebody/model/GetFaceEntityRequest.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_FACEBODY_MODEL_GETFACEENTITYREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_GETFACEENTITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT GetFaceEntityRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetFaceEntityRequest();
+				~GetFaceEntityRequest();
+
+				std::string getEntityId()const;
+				void setEntityId(const std::string& entityId);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string entityId_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_GETFACEENTITYREQUEST_H_

facebody/include/alibabacloud/facebody/model/GetFaceEntityResult.h

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

facebody/include/alibabacloud/facebody/model/HandPostureRequest.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_FACEBODY_MODEL_HANDPOSTUREREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTUREREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT HandPostureRequest : public RpcServiceRequest
+			{
+
+			public:
+				HandPostureRequest();
+				~HandPostureRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTUREREQUEST_H_

facebody/include/alibabacloud/facebody/model/HandPostureResult.h

@@ -0,0 +1,94 @@
+/*
+ * 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_FACEBODY_MODEL_HANDPOSTURERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTURERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT HandPostureResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct MetaObject
+					{
+						int height;
+						int width;
+					};
+					struct Output
+					{
+						struct Result
+						{
+							struct Box
+							{
+								struct Position
+								{
+									std::vector<std::string> points;
+								};
+								float confident;
+								std::vector<Position> positions;
+							};
+							struct Hands
+							{
+								struct KeyPoint
+								{
+									struct Position2
+									{
+										std::vector<std::string> points3;
+									};
+									std::vector<KeyPoint::Position2> positions1;
+									std::string label;
+								};
+								float confident;
+								std::vector<KeyPoint> keyPoints;
+							};
+							Hands hands;
+							Box box;
+						};
+						std::vector<Output::Result> results;
+						int handCount;
+					};
+					MetaObject metaObject;
+					std::vector<Output> outputs;
+				};
+
+
+				HandPostureResult();
+				explicit HandPostureResult(const std::string &payload);
+				~HandPostureResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_HANDPOSTURERESULT_H_

facebody/include/alibabacloud/facebody/model/ListFaceDbsRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ListFaceDbsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListFaceDbsRequest();
+				~ListFaceDbsRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEDBSREQUEST_H_

facebody/include/alibabacloud/facebody/model/ListFaceDbsResult.h

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

facebody/include/alibabacloud/facebody/model/ListFaceEntitiesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ListFaceEntitiesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListFaceEntitiesRequest();
+				~ListFaceEntitiesRequest();
+
+				std::string getEntityIdPrefix()const;
+				void setEntityIdPrefix(const std::string& entityIdPrefix);
+				int getLimit()const;
+				void setLimit(int limit);
+				std::string getOrder()const;
+				void setOrder(const std::string& order);
+				int getOffset()const;
+				void setOffset(int offset);
+				std::string getToken()const;
+				void setToken(const std::string& token);
+				std::string getLabels()const;
+				void setLabels(const std::string& labels);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string entityIdPrefix_;
+				int limit_;
+				std::string order_;
+				int offset_;
+				std::string token_;
+				std::string labels_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESREQUEST_H_

facebody/include/alibabacloud/facebody/model/ListFaceEntitiesResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ListFaceEntitiesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Entity
+					{
+						std::string entityId;
+						long createdAt;
+						std::string dbName;
+						std::string labels;
+						int faceCount;
+						long updatedAt;
+					};
+					int totalCount;
+					std::string token;
+					std::vector<Entity> entities;
+				};
+
+
+				ListFaceEntitiesResult();
+				explicit ListFaceEntitiesResult(const std::string &payload);
+				~ListFaceEntitiesResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_LISTFACEENTITIESRESULT_H_

facebody/include/alibabacloud/facebody/model/RecognizeActionRequest.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RecognizeActionRequest : public RpcServiceRequest
+			{
+			public:
+				struct URLList
+				{
+					std::string uRL;
+				};
+
+			public:
+				RecognizeActionRequest();
+				~RecognizeActionRequest();
+
+				std::vector<URLList> getURLList()const;
+				void setURLList(const std::vector<URLList>& uRLList);
+				int getType()const;
+				void setType(int type);
+				std::string getVideoUrl()const;
+				void setVideoUrl(const std::string& videoUrl);
+
+            private:
+				std::vector<URLList> uRLList_;
+				int type_;
+				std::string videoUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEACTIONREQUEST_H_

facebody/include/alibabacloud/facebody/model/RecognizeActionResult.h

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

facebody/include/alibabacloud/facebody/model/RecognizeExpressionRequest.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_FACEBODY_MODEL_RECOGNIZEEXPRESSIONREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RecognizeExpressionRequest : public RpcServiceRequest
+			{
+
+			public:
+				RecognizeExpressionRequest();
+				~RecognizeExpressionRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONREQUEST_H_

facebody/include/alibabacloud/facebody/model/RecognizeExpressionResult.h

@@ -0,0 +1,68 @@
+/*
+ * 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_FACEBODY_MODEL_RECOGNIZEEXPRESSIONRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RecognizeExpressionResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Element
+					{
+						struct FaceRectangle
+						{
+							int left;
+							int top;
+							int height;
+							int width;
+						};
+						std::string expression;
+						FaceRectangle faceRectangle;
+						float faceProbability;
+					};
+					std::vector<Element> elements;
+				};
+
+
+				RecognizeExpressionResult();
+				explicit RecognizeExpressionResult(const std::string &payload);
+				~RecognizeExpressionResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEEXPRESSIONRESULT_H_

facebody/include/alibabacloud/facebody/model/RecognizeFaceRequest.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_FACEBODY_MODEL_RECOGNIZEFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RecognizeFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				RecognizeFaceRequest();
+				~RecognizeFaceRequest();
+
+				int getImageType()const;
+				void setImageType(int imageType);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				int imageType_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/RecognizeFaceResult.h

@@ -0,0 +1,67 @@
+/*
+ * 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_FACEBODY_MODEL_RECOGNIZEFACERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RecognizeFaceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::vector<std::string> faceRectangles;
+					int denseFeatureLength;
+					std::vector<std::string> poseList;
+					std::vector<std::string> pupils;
+					std::vector<std::string> genderList;
+					std::vector<std::string> denseFeatures;
+					std::vector<std::string> faceProbabilityList;
+					int landmarkCount;
+					std::vector<std::string> ageList;
+					std::vector<std::string> glasses;
+					std::vector<std::string> landmarks;
+					std::vector<std::string> expressions;
+					int faceCount;
+				};
+
+
+				RecognizeFaceResult();
+				explicit RecognizeFaceResult(const std::string &payload);
+				~RecognizeFaceResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEFACERESULT_H_

facebody/include/alibabacloud/facebody/model/RecognizePublicFaceRequest.h

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

facebody/include/alibabacloud/facebody/model/RecognizePublicFaceResult.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT RecognizePublicFaceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Element
+					{
+						struct Result
+						{
+							struct SubResult
+							{
+								struct Face
+								{
+									float rate;
+									std::string id;
+									std::string name;
+								};
+								float w;
+								float h;
+								float x;
+								float y;
+								std::vector<SubResult::Face> faces;
+							};
+							std::string suggestion;
+							float rate;
+							std::string label;
+							std::vector<Result::SubResult> subResults;
+						};
+						std::string taskId;
+						std::vector<Element::Result> results;
+						std::string imageURL;
+					};
+					std::vector<Element> elements;
+				};
+
+
+				RecognizePublicFaceResult();
+				explicit RecognizePublicFaceResult(const std::string &payload);
+				~RecognizePublicFaceResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_RECOGNIZEPUBLICFACERESULT_H_

facebody/include/alibabacloud/facebody/model/SearchFaceRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACEREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT SearchFaceRequest : public RpcServiceRequest
+			{
+
+			public:
+				SearchFaceRequest();
+				~SearchFaceRequest();
+
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+				int getLimit()const;
+				void setLimit(int limit);
+
+            private:
+				std::string dbName_;
+				std::string imageUrl_;
+				int limit_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACEREQUEST_H_

facebody/include/alibabacloud/facebody/model/SearchFaceResult.h

@@ -0,0 +1,74 @@
+/*
+ * 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_FACEBODY_MODEL_SEARCHFACERESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT SearchFaceResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct MatchListItem
+					{
+						struct Location
+						{
+							int x;
+							int y;
+							int height;
+							int width;
+						};
+						struct FaceItemsItem
+						{
+							std::string faceId;
+							std::string entityId;
+							float score;
+							std::string extraData;
+						};
+						std::vector<MatchListItem::FaceItemsItem> faceItems;
+						Location location;
+					};
+					std::vector<MatchListItem> matchList;
+				};
+
+
+				SearchFaceResult();
+				explicit SearchFaceResult(const std::string &payload);
+				~SearchFaceResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_SEARCHFACERESULT_H_

facebody/include/alibabacloud/facebody/model/SwapFacialFeaturesRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT SwapFacialFeaturesRequest : public RpcServiceRequest
+			{
+
+			public:
+				SwapFacialFeaturesRequest();
+				~SwapFacialFeaturesRequest();
+
+				std::string getTargetImageURL()const;
+				void setTargetImageURL(const std::string& targetImageURL);
+				std::string getSourceImageURL()const;
+				void setSourceImageURL(const std::string& sourceImageURL);
+				std::string getEditPart()const;
+				void setEditPart(const std::string& editPart);
+
+            private:
+				std::string targetImageURL_;
+				std::string sourceImageURL_;
+				std::string editPart_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_SWAPFACIALFEATURESREQUEST_H_

facebody/include/alibabacloud/facebody/model/SwapFacialFeaturesResult.h

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

facebody/include/alibabacloud/facebody/model/UpdateFaceEntityRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT UpdateFaceEntityRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateFaceEntityRequest();
+				~UpdateFaceEntityRequest();
+
+				std::string getEntityId()const;
+				void setEntityId(const std::string& entityId);
+				std::string getLabels()const;
+				void setLabels(const std::string& labels);
+				std::string getDbName()const;
+				void setDbName(const std::string& dbName);
+
+            private:
+				std::string entityId_;
+				std::string labels_;
+				std::string dbName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYREQUEST_H_

facebody/include/alibabacloud/facebody/model/UpdateFaceEntityResult.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_FACEBODY_MODEL_UPDATEFACEENTITYRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT UpdateFaceEntityResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateFaceEntityResult();
+				explicit UpdateFaceEntityResult(const std::string &payload);
+				~UpdateFaceEntityResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_UPDATEFACEENTITYRESULT_H_

facebody/include/alibabacloud/facebody/model/VerifyFaceMaskRequest.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_FACEBODY_MODEL_VERIFYFACEMASKREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_VERIFYFACEMASKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT VerifyFaceMaskRequest : public RpcServiceRequest
+			{
+
+			public:
+				VerifyFaceMaskRequest();
+				~VerifyFaceMaskRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+				std::string getRefUrl()const;
+				void setRefUrl(const std::string& refUrl);
+
+            private:
+				std::string imageURL_;
+				std::string refUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_VERIFYFACEMASKREQUEST_H_

facebody/include/alibabacloud/facebody/model/VerifyFaceMaskResult.h

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

facebody/src/FacebodyClient.cc

@@ -28,21 +28,21 @@ namespace
 }
 
 FacebodyClient::FacebodyClient(const Credentials &credentials, const ClientConfiguration &configuration) :
-	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
 	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 FacebodyClient::FacebodyClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
-	RoaServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
 	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 FacebodyClient::FacebodyClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
-	RoaServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
 	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
@@ -51,36 +51,1368 @@ FacebodyClient::FacebodyClient(const std::string & accessKeyId, const std::strin
 FacebodyClient::~FacebodyClient()
 {}
 
+FacebodyClient::AddFaceOutcome FacebodyClient::addFace(const AddFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddFaceOutcome(AddFaceResult(outcome.result()));
+	else
+		return AddFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::addFaceAsync(const AddFaceRequest& request, const AddFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::AddFaceOutcomeCallable FacebodyClient::addFaceCallable(const AddFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->addFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::AddFaceEntityOutcome FacebodyClient::addFaceEntity(const AddFaceEntityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddFaceEntityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddFaceEntityOutcome(AddFaceEntityResult(outcome.result()));
+	else
+		return AddFaceEntityOutcome(outcome.error());
+}
+
+void FacebodyClient::addFaceEntityAsync(const AddFaceEntityRequest& request, const AddFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addFaceEntity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::AddFaceEntityOutcomeCallable FacebodyClient::addFaceEntityCallable(const AddFaceEntityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddFaceEntityOutcome()>>(
+			[this, request]()
+			{
+			return this->addFaceEntity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::BlurFaceOutcome FacebodyClient::blurFace(const BlurFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BlurFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BlurFaceOutcome(BlurFaceResult(outcome.result()));
+	else
+		return BlurFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::blurFaceAsync(const BlurFaceRequest& request, const BlurFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, blurFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::BlurFaceOutcomeCallable FacebodyClient::blurFaceCallable(const BlurFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BlurFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->blurFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::BodyPostureOutcome FacebodyClient::bodyPosture(const BodyPostureRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BodyPostureOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BodyPostureOutcome(BodyPostureResult(outcome.result()));
+	else
+		return BodyPostureOutcome(outcome.error());
+}
+
+void FacebodyClient::bodyPostureAsync(const BodyPostureRequest& request, const BodyPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, bodyPosture(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::BodyPostureOutcomeCallable FacebodyClient::bodyPostureCallable(const BodyPostureRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BodyPostureOutcome()>>(
+			[this, request]()
+			{
+			return this->bodyPosture(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::CompareFaceOutcome FacebodyClient::compareFace(const CompareFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CompareFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CompareFaceOutcome(CompareFaceResult(outcome.result()));
+	else
+		return CompareFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::compareFaceAsync(const CompareFaceRequest& request, const CompareFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, compareFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::CompareFaceOutcomeCallable FacebodyClient::compareFaceCallable(const CompareFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CompareFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->compareFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::CreateFaceDbOutcome FacebodyClient::createFaceDb(const CreateFaceDbRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateFaceDbOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateFaceDbOutcome(CreateFaceDbResult(outcome.result()));
+	else
+		return CreateFaceDbOutcome(outcome.error());
+}
+
+void FacebodyClient::createFaceDbAsync(const CreateFaceDbRequest& request, const CreateFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createFaceDb(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::CreateFaceDbOutcomeCallable FacebodyClient::createFaceDbCallable(const CreateFaceDbRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateFaceDbOutcome()>>(
+			[this, request]()
+			{
+			return this->createFaceDb(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DeleteFaceOutcome FacebodyClient::deleteFace(const DeleteFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceOutcome(DeleteFaceResult(outcome.result()));
+	else
+		return DeleteFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::deleteFaceAsync(const DeleteFaceRequest& request, const DeleteFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DeleteFaceOutcomeCallable FacebodyClient::deleteFaceCallable(const DeleteFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DeleteFaceDbOutcome FacebodyClient::deleteFaceDb(const DeleteFaceDbRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceDbOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceDbOutcome(DeleteFaceDbResult(outcome.result()));
+	else
+		return DeleteFaceDbOutcome(outcome.error());
+}
+
+void FacebodyClient::deleteFaceDbAsync(const DeleteFaceDbRequest& request, const DeleteFaceDbAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceDb(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DeleteFaceDbOutcomeCallable FacebodyClient::deleteFaceDbCallable(const DeleteFaceDbRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceDbOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceDb(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DeleteFaceEntityOutcome FacebodyClient::deleteFaceEntity(const DeleteFaceEntityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceEntityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceEntityOutcome(DeleteFaceEntityResult(outcome.result()));
+	else
+		return DeleteFaceEntityOutcome(outcome.error());
+}
+
+void FacebodyClient::deleteFaceEntityAsync(const DeleteFaceEntityRequest& request, const DeleteFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceEntity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DeleteFaceEntityOutcomeCallable FacebodyClient::deleteFaceEntityCallable(const DeleteFaceEntityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceEntityOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceEntity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectBodyCountOutcome FacebodyClient::detectBodyCount(const DetectBodyCountRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectBodyCountOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectBodyCountOutcome(DetectBodyCountResult(outcome.result()));
+	else
+		return DetectBodyCountOutcome(outcome.error());
+}
+
+void FacebodyClient::detectBodyCountAsync(const DetectBodyCountRequest& request, const DetectBodyCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectBodyCount(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectBodyCountOutcomeCallable FacebodyClient::detectBodyCountCallable(const DetectBodyCountRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectBodyCountOutcome()>>(
+			[this, request]()
+			{
+			return this->detectBodyCount(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectCelebrityOutcome FacebodyClient::detectCelebrity(const DetectCelebrityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectCelebrityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectCelebrityOutcome(DetectCelebrityResult(outcome.result()));
+	else
+		return DetectCelebrityOutcome(outcome.error());
+}
+
+void FacebodyClient::detectCelebrityAsync(const DetectCelebrityRequest& request, const DetectCelebrityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectCelebrity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectCelebrityOutcomeCallable FacebodyClient::detectCelebrityCallable(const DetectCelebrityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectCelebrityOutcome()>>(
+			[this, request]()
+			{
+			return this->detectCelebrity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectChefCapOutcome FacebodyClient::detectChefCap(const DetectChefCapRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectChefCapOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectChefCapOutcome(DetectChefCapResult(outcome.result()));
+	else
+		return DetectChefCapOutcome(outcome.error());
+}
+
+void FacebodyClient::detectChefCapAsync(const DetectChefCapRequest& request, const DetectChefCapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectChefCap(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectChefCapOutcomeCallable FacebodyClient::detectChefCapCallable(const DetectChefCapRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectChefCapOutcome()>>(
+			[this, request]()
+			{
+			return this->detectChefCap(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectFaceOutcome FacebodyClient::detectFace(const DetectFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectFaceOutcome(DetectFaceResult(outcome.result()));
+	else
+		return DetectFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::detectFaceAsync(const DetectFaceRequest& request, const DetectFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectFaceOutcomeCallable FacebodyClient::detectFaceCallable(const DetectFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->detectFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectIPCPedestrianOutcome FacebodyClient::detectIPCPedestrian(const DetectIPCPedestrianRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectIPCPedestrianOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectIPCPedestrianOutcome(DetectIPCPedestrianResult(outcome.result()));
+	else
+		return DetectIPCPedestrianOutcome(outcome.error());
+}
+
+void FacebodyClient::detectIPCPedestrianAsync(const DetectIPCPedestrianRequest& request, const DetectIPCPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectIPCPedestrian(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectIPCPedestrianOutcomeCallable FacebodyClient::detectIPCPedestrianCallable(const DetectIPCPedestrianRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectIPCPedestrianOutcome()>>(
+			[this, request]()
+			{
+			return this->detectIPCPedestrian(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FacebodyClient::DetectIPCPedestrianOptimizedOutcome FacebodyClient::detectIPCPedestrianOptimized(const DetectIPCPedestrianOptimizedRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DetectIPCPedestrianOptimizedOutcome(endpointOutcome.error());
+		return DetectIPCPedestrianOptimizedOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectIPCPedestrianOptimizedOutcome(DetectIPCPedestrianOptimizedResult(outcome.result()));
+	else
+		return DetectIPCPedestrianOptimizedOutcome(outcome.error());
+}
+
+void FacebodyClient::detectIPCPedestrianOptimizedAsync(const DetectIPCPedestrianOptimizedRequest& request, const DetectIPCPedestrianOptimizedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectIPCPedestrianOptimized(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectIPCPedestrianOptimizedOutcomeCallable FacebodyClient::detectIPCPedestrianOptimizedCallable(const DetectIPCPedestrianOptimizedRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectIPCPedestrianOptimizedOutcome()>>(
+			[this, request]()
+			{
+			return this->detectIPCPedestrianOptimized(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectLivingFaceOutcome FacebodyClient::detectLivingFace(const DetectLivingFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectLivingFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectLivingFaceOutcome(DetectLivingFaceResult(outcome.result()));
+	else
+		return DetectLivingFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::detectLivingFaceAsync(const DetectLivingFaceRequest& request, const DetectLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectLivingFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectLivingFaceOutcomeCallable FacebodyClient::detectLivingFaceCallable(const DetectLivingFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectLivingFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->detectLivingFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectMaskOutcome FacebodyClient::detectMask(const DetectMaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectMaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectMaskOutcome(DetectMaskResult(outcome.result()));
+	else
+		return DetectMaskOutcome(outcome.error());
+}
+
+void FacebodyClient::detectMaskAsync(const DetectMaskRequest& request, const DetectMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectMask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectMaskOutcomeCallable FacebodyClient::detectMaskCallable(const DetectMaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectMaskOutcome()>>(
+			[this, request]()
+			{
+			return this->detectMask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectPedestrianOutcome FacebodyClient::detectPedestrian(const DetectPedestrianRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectPedestrianOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectPedestrianOutcome(DetectPedestrianResult(outcome.result()));
+	else
+		return DetectPedestrianOutcome(outcome.error());
+}
+
+void FacebodyClient::detectPedestrianAsync(const DetectPedestrianRequest& request, const DetectPedestrianAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectPedestrian(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectPedestrianOutcomeCallable FacebodyClient::detectPedestrianCallable(const DetectPedestrianRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectPedestrianOutcome()>>(
+			[this, request]()
+			{
+			return this->detectPedestrian(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::DetectVideoLivingFaceOutcome FacebodyClient::detectVideoLivingFace(const DetectVideoLivingFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectVideoLivingFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectVideoLivingFaceOutcome(DetectVideoLivingFaceResult(outcome.result()));
+	else
+		return DetectVideoLivingFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::detectVideoLivingFaceAsync(const DetectVideoLivingFaceRequest& request, const DetectVideoLivingFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectVideoLivingFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectVideoLivingFaceOutcomeCallable FacebodyClient::detectVideoLivingFaceCallable(const DetectVideoLivingFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectVideoLivingFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->detectVideoLivingFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::EnhanceFaceOutcome FacebodyClient::enhanceFace(const EnhanceFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnhanceFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnhanceFaceOutcome(EnhanceFaceResult(outcome.result()));
+	else
+		return EnhanceFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::enhanceFaceAsync(const EnhanceFaceRequest& request, const EnhanceFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enhanceFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::EnhanceFaceOutcomeCallable FacebodyClient::enhanceFaceCallable(const EnhanceFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnhanceFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->enhanceFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::ExtractPedestrianFeatureAttrOutcome FacebodyClient::extractPedestrianFeatureAttr(const ExtractPedestrianFeatureAttrRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtractPedestrianFeatureAttrOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtractPedestrianFeatureAttrOutcome(ExtractPedestrianFeatureAttrResult(outcome.result()));
+	else
+		return ExtractPedestrianFeatureAttrOutcome(outcome.error());
+}
+
+void FacebodyClient::extractPedestrianFeatureAttrAsync(const ExtractPedestrianFeatureAttrRequest& request, const ExtractPedestrianFeatureAttrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extractPedestrianFeatureAttr(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::ExtractPedestrianFeatureAttrOutcomeCallable FacebodyClient::extractPedestrianFeatureAttrCallable(const ExtractPedestrianFeatureAttrRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtractPedestrianFeatureAttrOutcome()>>(
+			[this, request]()
+			{
+			return this->extractPedestrianFeatureAttr(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::ExtractPedestrianFeatureAttributeOutcome FacebodyClient::extractPedestrianFeatureAttribute(const ExtractPedestrianFeatureAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtractPedestrianFeatureAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtractPedestrianFeatureAttributeOutcome(ExtractPedestrianFeatureAttributeResult(outcome.result()));
+	else
+		return ExtractPedestrianFeatureAttributeOutcome(outcome.error());
+}
+
+void FacebodyClient::extractPedestrianFeatureAttributeAsync(const ExtractPedestrianFeatureAttributeRequest& request, const ExtractPedestrianFeatureAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extractPedestrianFeatureAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::ExtractPedestrianFeatureAttributeOutcomeCallable FacebodyClient::extractPedestrianFeatureAttributeCallable(const ExtractPedestrianFeatureAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtractPedestrianFeatureAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->extractPedestrianFeatureAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::FaceBeautyOutcome FacebodyClient::faceBeauty(const FaceBeautyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FaceBeautyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FaceBeautyOutcome(FaceBeautyResult(outcome.result()));
+	else
+		return FaceBeautyOutcome(outcome.error());
+}
+
+void FacebodyClient::faceBeautyAsync(const FaceBeautyRequest& request, const FaceBeautyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, faceBeauty(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::FaceBeautyOutcomeCallable FacebodyClient::faceBeautyCallable(const FaceBeautyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FaceBeautyOutcome()>>(
+			[this, request]()
+			{
+			return this->faceBeauty(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::FaceFilterOutcome FacebodyClient::faceFilter(const FaceFilterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FaceFilterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FaceFilterOutcome(FaceFilterResult(outcome.result()));
+	else
+		return FaceFilterOutcome(outcome.error());
+}
+
+void FacebodyClient::faceFilterAsync(const FaceFilterRequest& request, const FaceFilterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, faceFilter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::FaceFilterOutcomeCallable FacebodyClient::faceFilterCallable(const FaceFilterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FaceFilterOutcome()>>(
+			[this, request]()
+			{
+			return this->faceFilter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::FaceMakeupOutcome FacebodyClient::faceMakeup(const FaceMakeupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FaceMakeupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FaceMakeupOutcome(FaceMakeupResult(outcome.result()));
+	else
+		return FaceMakeupOutcome(outcome.error());
+}
+
+void FacebodyClient::faceMakeupAsync(const FaceMakeupRequest& request, const FaceMakeupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, faceMakeup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::FaceMakeupOutcomeCallable FacebodyClient::faceMakeupCallable(const FaceMakeupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FaceMakeupOutcome()>>(
+			[this, request]()
+			{
+			return this->faceMakeup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::FaceTidyupOutcome FacebodyClient::faceTidyup(const FaceTidyupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FaceTidyupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FaceTidyupOutcome(FaceTidyupResult(outcome.result()));
+	else
+		return FaceTidyupOutcome(outcome.error());
+}
+
+void FacebodyClient::faceTidyupAsync(const FaceTidyupRequest& request, const FaceTidyupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, faceTidyup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::FaceTidyupOutcomeCallable FacebodyClient::faceTidyupCallable(const FaceTidyupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FaceTidyupOutcome()>>(
+			[this, request]()
+			{
+			return this->faceTidyup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::GetFaceEntityOutcome FacebodyClient::getFaceEntity(const GetFaceEntityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetFaceEntityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetFaceEntityOutcome(GetFaceEntityResult(outcome.result()));
+	else
+		return GetFaceEntityOutcome(outcome.error());
+}
+
+void FacebodyClient::getFaceEntityAsync(const GetFaceEntityRequest& request, const GetFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getFaceEntity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::GetFaceEntityOutcomeCallable FacebodyClient::getFaceEntityCallable(const GetFaceEntityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetFaceEntityOutcome()>>(
+			[this, request]()
+			{
+			return this->getFaceEntity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::HandPostureOutcome FacebodyClient::handPosture(const HandPostureRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return HandPostureOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return HandPostureOutcome(HandPostureResult(outcome.result()));
+	else
+		return HandPostureOutcome(outcome.error());
+}
+
+void FacebodyClient::handPostureAsync(const HandPostureRequest& request, const HandPostureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, handPosture(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::HandPostureOutcomeCallable FacebodyClient::handPostureCallable(const HandPostureRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<HandPostureOutcome()>>(
+			[this, request]()
+			{
+			return this->handPosture(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::ListFaceDbsOutcome FacebodyClient::listFaceDbs(const ListFaceDbsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListFaceDbsOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DetectIPCPedestrianOptimizedOutcome(DetectIPCPedestrianOptimizedResult(outcome.result()));
+		return ListFaceDbsOutcome(ListFaceDbsResult(outcome.result()));
 	else
-		return DetectIPCPedestrianOptimizedOutcome(outcome.error());
+		return ListFaceDbsOutcome(outcome.error());
 }
 
-void FacebodyClient::detectIPCPedestrianOptimizedAsync(const DetectIPCPedestrianOptimizedRequest& request, const DetectIPCPedestrianOptimizedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void FacebodyClient::listFaceDbsAsync(const ListFaceDbsRequest& request, const ListFaceDbsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, detectIPCPedestrianOptimized(request), context);
+		handler(this, request, listFaceDbs(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-FacebodyClient::DetectIPCPedestrianOptimizedOutcomeCallable FacebodyClient::detectIPCPedestrianOptimizedCallable(const DetectIPCPedestrianOptimizedRequest &request) const
+FacebodyClient::ListFaceDbsOutcomeCallable FacebodyClient::listFaceDbsCallable(const ListFaceDbsRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DetectIPCPedestrianOptimizedOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<ListFaceDbsOutcome()>>(
 			[this, request]()
 			{
-			return this->detectIPCPedestrianOptimized(request);
+			return this->listFaceDbs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::ListFaceEntitiesOutcome FacebodyClient::listFaceEntities(const ListFaceEntitiesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListFaceEntitiesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListFaceEntitiesOutcome(ListFaceEntitiesResult(outcome.result()));
+	else
+		return ListFaceEntitiesOutcome(outcome.error());
+}
+
+void FacebodyClient::listFaceEntitiesAsync(const ListFaceEntitiesRequest& request, const ListFaceEntitiesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listFaceEntities(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::ListFaceEntitiesOutcomeCallable FacebodyClient::listFaceEntitiesCallable(const ListFaceEntitiesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListFaceEntitiesOutcome()>>(
+			[this, request]()
+			{
+			return this->listFaceEntities(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::RecognizeActionOutcome FacebodyClient::recognizeAction(const RecognizeActionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecognizeActionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecognizeActionOutcome(RecognizeActionResult(outcome.result()));
+	else
+		return RecognizeActionOutcome(outcome.error());
+}
+
+void FacebodyClient::recognizeActionAsync(const RecognizeActionRequest& request, const RecognizeActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recognizeAction(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::RecognizeActionOutcomeCallable FacebodyClient::recognizeActionCallable(const RecognizeActionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecognizeActionOutcome()>>(
+			[this, request]()
+			{
+			return this->recognizeAction(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::RecognizeExpressionOutcome FacebodyClient::recognizeExpression(const RecognizeExpressionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecognizeExpressionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecognizeExpressionOutcome(RecognizeExpressionResult(outcome.result()));
+	else
+		return RecognizeExpressionOutcome(outcome.error());
+}
+
+void FacebodyClient::recognizeExpressionAsync(const RecognizeExpressionRequest& request, const RecognizeExpressionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recognizeExpression(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::RecognizeExpressionOutcomeCallable FacebodyClient::recognizeExpressionCallable(const RecognizeExpressionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecognizeExpressionOutcome()>>(
+			[this, request]()
+			{
+			return this->recognizeExpression(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::RecognizeFaceOutcome FacebodyClient::recognizeFace(const RecognizeFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecognizeFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecognizeFaceOutcome(RecognizeFaceResult(outcome.result()));
+	else
+		return RecognizeFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::recognizeFaceAsync(const RecognizeFaceRequest& request, const RecognizeFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recognizeFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::RecognizeFaceOutcomeCallable FacebodyClient::recognizeFaceCallable(const RecognizeFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecognizeFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->recognizeFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::RecognizePublicFaceOutcome FacebodyClient::recognizePublicFace(const RecognizePublicFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RecognizePublicFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RecognizePublicFaceOutcome(RecognizePublicFaceResult(outcome.result()));
+	else
+		return RecognizePublicFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::recognizePublicFaceAsync(const RecognizePublicFaceRequest& request, const RecognizePublicFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, recognizePublicFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::RecognizePublicFaceOutcomeCallable FacebodyClient::recognizePublicFaceCallable(const RecognizePublicFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RecognizePublicFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->recognizePublicFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::SearchFaceOutcome FacebodyClient::searchFace(const SearchFaceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchFaceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchFaceOutcome(SearchFaceResult(outcome.result()));
+	else
+		return SearchFaceOutcome(outcome.error());
+}
+
+void FacebodyClient::searchFaceAsync(const SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchFace(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::SearchFaceOutcomeCallable FacebodyClient::searchFaceCallable(const SearchFaceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchFaceOutcome()>>(
+			[this, request]()
+			{
+			return this->searchFace(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::SwapFacialFeaturesOutcome FacebodyClient::swapFacialFeatures(const SwapFacialFeaturesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SwapFacialFeaturesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SwapFacialFeaturesOutcome(SwapFacialFeaturesResult(outcome.result()));
+	else
+		return SwapFacialFeaturesOutcome(outcome.error());
+}
+
+void FacebodyClient::swapFacialFeaturesAsync(const SwapFacialFeaturesRequest& request, const SwapFacialFeaturesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, swapFacialFeatures(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::SwapFacialFeaturesOutcomeCallable FacebodyClient::swapFacialFeaturesCallable(const SwapFacialFeaturesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SwapFacialFeaturesOutcome()>>(
+			[this, request]()
+			{
+			return this->swapFacialFeatures(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::UpdateFaceEntityOutcome FacebodyClient::updateFaceEntity(const UpdateFaceEntityRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateFaceEntityOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateFaceEntityOutcome(UpdateFaceEntityResult(outcome.result()));
+	else
+		return UpdateFaceEntityOutcome(outcome.error());
+}
+
+void FacebodyClient::updateFaceEntityAsync(const UpdateFaceEntityRequest& request, const UpdateFaceEntityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateFaceEntity(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::UpdateFaceEntityOutcomeCallable FacebodyClient::updateFaceEntityCallable(const UpdateFaceEntityRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateFaceEntityOutcome()>>(
+			[this, request]()
+			{
+			return this->updateFaceEntity(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+FacebodyClient::VerifyFaceMaskOutcome FacebodyClient::verifyFaceMask(const VerifyFaceMaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VerifyFaceMaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VerifyFaceMaskOutcome(VerifyFaceMaskResult(outcome.result()));
+	else
+		return VerifyFaceMaskOutcome(outcome.error());
+}
+
+void FacebodyClient::verifyFaceMaskAsync(const VerifyFaceMaskRequest& request, const VerifyFaceMaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, verifyFaceMask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::VerifyFaceMaskOutcomeCallable FacebodyClient::verifyFaceMaskCallable(const VerifyFaceMaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VerifyFaceMaskOutcome()>>(
+			[this, request]()
+			{
+			return this->verifyFaceMask(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));

facebody/src/model/AddFaceEntityRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/AddFaceEntityRequest.h>
+
+using AlibabaCloud::Facebody::Model::AddFaceEntityRequest;
+
+AddFaceEntityRequest::AddFaceEntityRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "AddFaceEntity")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddFaceEntityRequest::~AddFaceEntityRequest()
+{}
+
+std::string AddFaceEntityRequest::getEntityId()const
+{
+	return entityId_;
+}
+
+void AddFaceEntityRequest::setEntityId(const std::string& entityId)
+{
+	entityId_ = entityId;
+	setBodyParameter("EntityId", entityId);
+}
+
+std::string AddFaceEntityRequest::getLabels()const
+{
+	return labels_;
+}
+
+void AddFaceEntityRequest::setLabels(const std::string& labels)
+{
+	labels_ = labels;
+	setBodyParameter("Labels", labels);
+}
+
+std::string AddFaceEntityRequest::getDbName()const
+{
+	return dbName_;
+}
+
+void AddFaceEntityRequest::setDbName(const std::string& dbName)
+{
+	dbName_ = dbName;
+	setBodyParameter("DbName", dbName);
+}
+

facebody/src/model/AddFaceEntityResult.cc

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

facebody/src/model/AddFaceRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/AddFaceRequest.h>
+
+using AlibabaCloud::Facebody::Model::AddFaceRequest;
+
+AddFaceRequest::AddFaceRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "AddFace")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddFaceRequest::~AddFaceRequest()
+{}
+
+std::string AddFaceRequest::getEntityId()const
+{
+	return entityId_;
+}
+
+void AddFaceRequest::setEntityId(const std::string& entityId)
+{
+	entityId_ = entityId;
+	setBodyParameter("EntityId", entityId);
+}
+
+std::string AddFaceRequest::getDbName()const
+{
+	return dbName_;
+}
+
+void AddFaceRequest::setDbName(const std::string& dbName)
+{
+	dbName_ = dbName;
+	setBodyParameter("DbName", dbName);
+}
+
+std::string AddFaceRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void AddFaceRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setBodyParameter("ImageUrl", imageUrl);
+}
+
+std::string AddFaceRequest::getExtraData()const
+{
+	return extraData_;
+}
+
+void AddFaceRequest::setExtraData(const std::string& extraData)
+{
+	extraData_ = extraData;
+	setBodyParameter("ExtraData", extraData);
+}
+

facebody/src/model/AddFaceResult.cc

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

facebody/src/model/BlurFaceRequest.cc

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

facebody/src/model/BlurFaceResult.cc

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

facebody/src/model/BodyPostureRequest.cc

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

facebody/src/model/BodyPostureResult.cc

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/BodyPostureResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Facebody;
+using namespace AlibabaCloud::Facebody::Model;
+
+BodyPostureResult::BodyPostureResult() :
+	ServiceResult()
+{}
+
+BodyPostureResult::BodyPostureResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BodyPostureResult::~BodyPostureResult()
+{}
+
+void BodyPostureResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allOutputsNode = dataNode["Outputs"]["Output"];
+	for (auto dataNodeOutputsOutput : allOutputsNode)
+	{
+		Data::Output outputObject;
+		if(!dataNodeOutputsOutput["HumanCount"].isNull())
+			outputObject.humanCount = std::stoi(dataNodeOutputsOutput["HumanCount"].asString());
+		auto allResultsNode = allOutputsNode["Results"]["Result"];
+		for (auto allOutputsNodeResultsResult : allResultsNode)
+		{
+			Data::Output::Result resultsObject;
+			auto allBodiesNode = allResultsNode["Bodies"]["Body"];
+			for (auto allResultsNodeBodiesBody : allBodiesNode)
+			{
+				Data::Output::Result::Body bodiesObject;
+				if(!allResultsNodeBodiesBody["Confident"].isNull())
+					bodiesObject.confident = std::stof(allResultsNodeBodiesBody["Confident"].asString());
+				if(!allResultsNodeBodiesBody["Label"].isNull())
+					bodiesObject.label = allResultsNodeBodiesBody["Label"].asString();
+				auto allPositionsNode = allBodiesNode["Positions"]["Position"];
+				for (auto allBodiesNodePositionsPosition : allPositionsNode)
+				{
+					Data::Output::Result::Body::Position positionsObject;
+					auto allPoints = value["Points"]["Point"];
+					for (auto value : allPoints)
+						positionsObject.points.push_back(value.asString());
+					bodiesObject.positions.push_back(positionsObject);
+				}
+				resultsObject.bodies.push_back(bodiesObject);
+			}
+			outputObject.results.push_back(resultsObject);
+		}
+		data_.outputs.push_back(outputObject);
+	}
+	auto metaObjectNode = dataNode["MetaObject"];
+	if(!metaObjectNode["Height"].isNull())
+		data_.metaObject.height = std::stoi(metaObjectNode["Height"].asString());
+	if(!metaObjectNode["Width"].isNull())
+		data_.metaObject.width = std::stoi(metaObjectNode["Width"].asString());
+
+}
+
+BodyPostureResult::Data BodyPostureResult::getData()const
+{
+	return data_;
+}
+

facebody/src/model/CompareFaceRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/CompareFaceRequest.h>
+
+using AlibabaCloud::Facebody::Model::CompareFaceRequest;
+
+CompareFaceRequest::CompareFaceRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "CompareFace")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CompareFaceRequest::~CompareFaceRequest()
+{}
+
+int CompareFaceRequest::getImageType()const
+{
+	return imageType_;
+}
+
+void CompareFaceRequest::setImageType(int imageType)
+{
+	imageType_ = imageType;
+	setBodyParameter("ImageType", std::to_string(imageType));
+}
+
+std::string CompareFaceRequest::getImageURLB()const
+{
+	return imageURLB_;
+}
+
+void CompareFaceRequest::setImageURLB(const std::string& imageURLB)
+{
+	imageURLB_ = imageURLB;
+	setBodyParameter("ImageURLB", imageURLB);
+}
+
+std::string CompareFaceRequest::getImageURLA()const
+{
+	return imageURLA_;
+}
+
+void CompareFaceRequest::setImageURLA(const std::string& imageURLA)
+{
+	imageURLA_ = imageURLA;
+	setBodyParameter("ImageURLA", imageURLA);
+}
+

facebody/src/model/CompareFaceResult.cc

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

facebody/src/model/CreateFaceDbRequest.cc

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

facebody/src/model/CreateFaceDbResult.cc

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

facebody/src/model/DeleteFaceDbRequest.cc

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

facebody/src/model/DeleteFaceDbResult.cc

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

facebody/src/model/DeleteFaceEntityRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/DeleteFaceEntityRequest.h>
+
+using AlibabaCloud::Facebody::Model::DeleteFaceEntityRequest;
+
+DeleteFaceEntityRequest::DeleteFaceEntityRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "DeleteFaceEntity")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFaceEntityRequest::~DeleteFaceEntityRequest()
+{}
+
+std::string DeleteFaceEntityRequest::getEntityId()const
+{
+	return entityId_;
+}
+
+void DeleteFaceEntityRequest::setEntityId(const std::string& entityId)
+{
+	entityId_ = entityId;
+	setBodyParameter("EntityId", entityId);
+}
+
+std::string DeleteFaceEntityRequest::getDbName()const
+{
+	return dbName_;
+}
+
+void DeleteFaceEntityRequest::setDbName(const std::string& dbName)
+{
+	dbName_ = dbName;
+	setBodyParameter("DbName", dbName);
+}
+

facebody/src/model/DeleteFaceEntityResult.cc

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

facebody/src/model/DeleteFaceRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/DeleteFaceRequest.h>
+
+using AlibabaCloud::Facebody::Model::DeleteFaceRequest;
+
+DeleteFaceRequest::DeleteFaceRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "DeleteFace")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFaceRequest::~DeleteFaceRequest()
+{}
+
+std::string DeleteFaceRequest::getFaceId()const
+{
+	return faceId_;
+}
+
+void DeleteFaceRequest::setFaceId(const std::string& faceId)
+{
+	faceId_ = faceId;
+	setBodyParameter("FaceId", faceId);
+}
+
+std::string DeleteFaceRequest::getDbName()const
+{
+	return dbName_;
+}
+
+void DeleteFaceRequest::setDbName(const std::string& dbName)
+{
+	dbName_ = dbName;
+	setBodyParameter("DbName", dbName);
+}
+

facebody/src/model/DeleteFaceResult.cc

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

facebody/src/model/DetectBodyCountRequest.cc

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

facebody/src/model/DetectBodyCountResult.cc

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

facebody/src/model/DetectCelebrityRequest.cc

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

facebody/src/model/DetectCelebrityResult.cc

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