Generated 2019-09-28 for reid.

CHANGELOG

@@ -1,3 +1,6 @@
+2019-12-19 Version 1.36.217
+- Generated 2019-09-28 for `reid`.
+
 2019-12-19 Version 1.36.216
 - DescribeNetworkInterfaces Supports NextToken.
 

VERSION

@@ -1 +1 @@
-1.36.216
+1.36.217

reid/CMakeLists.txt

@@ -0,0 +1,134 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(reid_public_header 
+	include/alibabacloud/reid/ReidClient.h
+	include/alibabacloud/reid/ReidExport.h )
+
+set(reid_public_header_model 
+	include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.h
+	include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h
+	include/alibabacloud/reid/model/DescribeCursorRequest.h
+	include/alibabacloud/reid/model/DescribeCursorResult.h
+	include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h
+	include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h
+	include/alibabacloud/reid/model/DescribeHeatMapRequest.h
+	include/alibabacloud/reid/model/DescribeHeatMapResult.h
+	include/alibabacloud/reid/model/DescribeImageUrlsRequest.h
+	include/alibabacloud/reid/model/DescribeImageUrlsResult.h
+	include/alibabacloud/reid/model/DescribeOverviewDataRequest.h
+	include/alibabacloud/reid/model/DescribeOverviewDataResult.h
+	include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h
+	include/alibabacloud/reid/model/ImportSpecialPersonnelResult.h
+	include/alibabacloud/reid/model/ListActionDataRequest.h
+	include/alibabacloud/reid/model/ListActionDataResult.h
+	include/alibabacloud/reid/model/ListEmapRequest.h
+	include/alibabacloud/reid/model/ListEmapResult.h
+	include/alibabacloud/reid/model/ListLocationRequest.h
+	include/alibabacloud/reid/model/ListLocationResult.h
+	include/alibabacloud/reid/model/ListPersonByImageRequest.h
+	include/alibabacloud/reid/model/ListPersonByImageResult.h
+	include/alibabacloud/reid/model/ListStoreRequest.h
+	include/alibabacloud/reid/model/ListStoreResult.h
+	include/alibabacloud/reid/model/PullActionDataRequest.h
+	include/alibabacloud/reid/model/PullActionDataResult.h )
+
+set(reid_src 
+	src/ReidClient.cc
+	src/model/DescribeBaseStatisticsRequest.cc
+	src/model/DescribeBaseStatisticsResult.cc
+	src/model/DescribeCursorRequest.cc
+	src/model/DescribeCursorResult.cc
+	src/model/DescribeCustomerFlowByLocationRequest.cc
+	src/model/DescribeCustomerFlowByLocationResult.cc
+	src/model/DescribeHeatMapRequest.cc
+	src/model/DescribeHeatMapResult.cc
+	src/model/DescribeImageUrlsRequest.cc
+	src/model/DescribeImageUrlsResult.cc
+	src/model/DescribeOverviewDataRequest.cc
+	src/model/DescribeOverviewDataResult.cc
+	src/model/ImportSpecialPersonnelRequest.cc
+	src/model/ImportSpecialPersonnelResult.cc
+	src/model/ListActionDataRequest.cc
+	src/model/ListActionDataResult.cc
+	src/model/ListEmapRequest.cc
+	src/model/ListEmapResult.cc
+	src/model/ListLocationRequest.cc
+	src/model/ListLocationResult.cc
+	src/model/ListPersonByImageRequest.cc
+	src/model/ListPersonByImageResult.cc
+	src/model/ListStoreRequest.cc
+	src/model/ListStoreResult.cc
+	src/model/PullActionDataRequest.cc
+	src/model/PullActionDataResult.cc )
+
+add_library(reid ${LIB_TYPE}
+	${reid_public_header}
+	${reid_public_header_model}
+	${reid_src})
+
+set_target_properties(reid
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}reid
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(reid
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_REID_LIBRARY)
+endif()
+
+target_include_directories(reid
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(reid
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(reid
+		jsoncpp)
+	target_include_directories(reid
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(reid
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(reid
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(reid
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(reid
+		jsoncpp)
+endif()
+
+install(FILES ${reid_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/reid)
+install(FILES ${reid_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/reid/model)
+install(TARGETS reid
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

reid/include/alibabacloud/reid/ReidClient.h

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_REID_REIDCLIENT_H_
+#define ALIBABACLOUD_REID_REIDCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ReidExport.h"
+#include "model/DescribeBaseStatisticsRequest.h"
+#include "model/DescribeBaseStatisticsResult.h"
+#include "model/DescribeCursorRequest.h"
+#include "model/DescribeCursorResult.h"
+#include "model/DescribeCustomerFlowByLocationRequest.h"
+#include "model/DescribeCustomerFlowByLocationResult.h"
+#include "model/DescribeHeatMapRequest.h"
+#include "model/DescribeHeatMapResult.h"
+#include "model/DescribeImageUrlsRequest.h"
+#include "model/DescribeImageUrlsResult.h"
+#include "model/DescribeOverviewDataRequest.h"
+#include "model/DescribeOverviewDataResult.h"
+#include "model/ImportSpecialPersonnelRequest.h"
+#include "model/ImportSpecialPersonnelResult.h"
+#include "model/ListActionDataRequest.h"
+#include "model/ListActionDataResult.h"
+#include "model/ListEmapRequest.h"
+#include "model/ListEmapResult.h"
+#include "model/ListLocationRequest.h"
+#include "model/ListLocationResult.h"
+#include "model/ListPersonByImageRequest.h"
+#include "model/ListPersonByImageResult.h"
+#include "model/ListStoreRequest.h"
+#include "model/ListStoreResult.h"
+#include "model/PullActionDataRequest.h"
+#include "model/PullActionDataResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		class ALIBABACLOUD_REID_EXPORT ReidClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::DescribeBaseStatisticsResult> DescribeBaseStatisticsOutcome;
+			typedef std::future<DescribeBaseStatisticsOutcome> DescribeBaseStatisticsOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::DescribeBaseStatisticsRequest&, const DescribeBaseStatisticsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBaseStatisticsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCursorResult> DescribeCursorOutcome;
+			typedef std::future<DescribeCursorOutcome> DescribeCursorOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::DescribeCursorRequest&, const DescribeCursorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCursorAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCustomerFlowByLocationResult> DescribeCustomerFlowByLocationOutcome;
+			typedef std::future<DescribeCustomerFlowByLocationOutcome> DescribeCustomerFlowByLocationOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::DescribeCustomerFlowByLocationRequest&, const DescribeCustomerFlowByLocationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCustomerFlowByLocationAsyncHandler;
+			typedef Outcome<Error, Model::DescribeHeatMapResult> DescribeHeatMapOutcome;
+			typedef std::future<DescribeHeatMapOutcome> DescribeHeatMapOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::DescribeHeatMapRequest&, const DescribeHeatMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHeatMapAsyncHandler;
+			typedef Outcome<Error, Model::DescribeImageUrlsResult> DescribeImageUrlsOutcome;
+			typedef std::future<DescribeImageUrlsOutcome> DescribeImageUrlsOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::DescribeImageUrlsRequest&, const DescribeImageUrlsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageUrlsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeOverviewDataResult> DescribeOverviewDataOutcome;
+			typedef std::future<DescribeOverviewDataOutcome> DescribeOverviewDataOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::DescribeOverviewDataRequest&, const DescribeOverviewDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOverviewDataAsyncHandler;
+			typedef Outcome<Error, Model::ImportSpecialPersonnelResult> ImportSpecialPersonnelOutcome;
+			typedef std::future<ImportSpecialPersonnelOutcome> ImportSpecialPersonnelOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::ImportSpecialPersonnelRequest&, const ImportSpecialPersonnelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportSpecialPersonnelAsyncHandler;
+			typedef Outcome<Error, Model::ListActionDataResult> ListActionDataOutcome;
+			typedef std::future<ListActionDataOutcome> ListActionDataOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::ListActionDataRequest&, const ListActionDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListActionDataAsyncHandler;
+			typedef Outcome<Error, Model::ListEmapResult> ListEmapOutcome;
+			typedef std::future<ListEmapOutcome> ListEmapOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::ListEmapRequest&, const ListEmapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListEmapAsyncHandler;
+			typedef Outcome<Error, Model::ListLocationResult> ListLocationOutcome;
+			typedef std::future<ListLocationOutcome> ListLocationOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::ListLocationRequest&, const ListLocationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLocationAsyncHandler;
+			typedef Outcome<Error, Model::ListPersonByImageResult> ListPersonByImageOutcome;
+			typedef std::future<ListPersonByImageOutcome> ListPersonByImageOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::ListPersonByImageRequest&, const ListPersonByImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPersonByImageAsyncHandler;
+			typedef Outcome<Error, Model::ListStoreResult> ListStoreOutcome;
+			typedef std::future<ListStoreOutcome> ListStoreOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::ListStoreRequest&, const ListStoreOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStoreAsyncHandler;
+			typedef Outcome<Error, Model::PullActionDataResult> PullActionDataOutcome;
+			typedef std::future<PullActionDataOutcome> PullActionDataOutcomeCallable;
+			typedef std::function<void(const ReidClient*, const Model::PullActionDataRequest&, const PullActionDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PullActionDataAsyncHandler;
+
+			ReidClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ReidClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ReidClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ReidClient();
+			DescribeBaseStatisticsOutcome describeBaseStatistics(const Model::DescribeBaseStatisticsRequest &request)const;
+			void describeBaseStatisticsAsync(const Model::DescribeBaseStatisticsRequest& request, const DescribeBaseStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeBaseStatisticsOutcomeCallable describeBaseStatisticsCallable(const Model::DescribeBaseStatisticsRequest& request) const;
+			DescribeCursorOutcome describeCursor(const Model::DescribeCursorRequest &request)const;
+			void describeCursorAsync(const Model::DescribeCursorRequest& request, const DescribeCursorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCursorOutcomeCallable describeCursorCallable(const Model::DescribeCursorRequest& request) const;
+			DescribeCustomerFlowByLocationOutcome describeCustomerFlowByLocation(const Model::DescribeCustomerFlowByLocationRequest &request)const;
+			void describeCustomerFlowByLocationAsync(const Model::DescribeCustomerFlowByLocationRequest& request, const DescribeCustomerFlowByLocationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCustomerFlowByLocationOutcomeCallable describeCustomerFlowByLocationCallable(const Model::DescribeCustomerFlowByLocationRequest& request) const;
+			DescribeHeatMapOutcome describeHeatMap(const Model::DescribeHeatMapRequest &request)const;
+			void describeHeatMapAsync(const Model::DescribeHeatMapRequest& request, const DescribeHeatMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeHeatMapOutcomeCallable describeHeatMapCallable(const Model::DescribeHeatMapRequest& request) const;
+			DescribeImageUrlsOutcome describeImageUrls(const Model::DescribeImageUrlsRequest &request)const;
+			void describeImageUrlsAsync(const Model::DescribeImageUrlsRequest& request, const DescribeImageUrlsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeImageUrlsOutcomeCallable describeImageUrlsCallable(const Model::DescribeImageUrlsRequest& request) const;
+			DescribeOverviewDataOutcome describeOverviewData(const Model::DescribeOverviewDataRequest &request)const;
+			void describeOverviewDataAsync(const Model::DescribeOverviewDataRequest& request, const DescribeOverviewDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeOverviewDataOutcomeCallable describeOverviewDataCallable(const Model::DescribeOverviewDataRequest& request) const;
+			ImportSpecialPersonnelOutcome importSpecialPersonnel(const Model::ImportSpecialPersonnelRequest &request)const;
+			void importSpecialPersonnelAsync(const Model::ImportSpecialPersonnelRequest& request, const ImportSpecialPersonnelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImportSpecialPersonnelOutcomeCallable importSpecialPersonnelCallable(const Model::ImportSpecialPersonnelRequest& request) const;
+			ListActionDataOutcome listActionData(const Model::ListActionDataRequest &request)const;
+			void listActionDataAsync(const Model::ListActionDataRequest& request, const ListActionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListActionDataOutcomeCallable listActionDataCallable(const Model::ListActionDataRequest& request) const;
+			ListEmapOutcome listEmap(const Model::ListEmapRequest &request)const;
+			void listEmapAsync(const Model::ListEmapRequest& request, const ListEmapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListEmapOutcomeCallable listEmapCallable(const Model::ListEmapRequest& request) const;
+			ListLocationOutcome listLocation(const Model::ListLocationRequest &request)const;
+			void listLocationAsync(const Model::ListLocationRequest& request, const ListLocationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListLocationOutcomeCallable listLocationCallable(const Model::ListLocationRequest& request) const;
+			ListPersonByImageOutcome listPersonByImage(const Model::ListPersonByImageRequest &request)const;
+			void listPersonByImageAsync(const Model::ListPersonByImageRequest& request, const ListPersonByImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPersonByImageOutcomeCallable listPersonByImageCallable(const Model::ListPersonByImageRequest& request) const;
+			ListStoreOutcome listStore(const Model::ListStoreRequest &request)const;
+			void listStoreAsync(const Model::ListStoreRequest& request, const ListStoreAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListStoreOutcomeCallable listStoreCallable(const Model::ListStoreRequest& request) const;
+			PullActionDataOutcome pullActionData(const Model::PullActionDataRequest &request)const;
+			void pullActionDataAsync(const Model::PullActionDataRequest& request, const PullActionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PullActionDataOutcomeCallable pullActionDataCallable(const Model::PullActionDataRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_REID_REIDCLIENT_H_

reid/include/alibabacloud/reid/ReidExport.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_REID_REIDEXPORT_H_
+#define ALIBABACLOUD_REID_REIDEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_REID_LIBRARY)
+#		define ALIBABACLOUD_REID_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_REID_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_REID_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_REID_REIDEXPORT_H_

reid/include/alibabacloud/reid/model/DescribeBaseStatisticsRequest.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_REID_MODEL_DESCRIBEBASESTATISTICSREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeBaseStatisticsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeBaseStatisticsRequest();
+				~DescribeBaseStatisticsRequest();
+
+				std::string getDate()const;
+				void setDate(const std::string& date);
+				std::string getExtraStatisticTypes()const;
+				void setExtraStatisticTypes(const std::string& extraStatisticTypes);
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				std::string getSummaryType()const;
+				void setSummaryType(const std::string& summaryType);
+				long getLocationId()const;
+				void setLocationId(long locationId);
+
+            private:
+				std::string date_;
+				std::string extraStatisticTypes_;
+				long storeId_;
+				std::string summaryType_;
+				long locationId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSREQUEST_H_

reid/include/alibabacloud/reid/model/DescribeBaseStatisticsResult.h

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_REID_MODEL_DESCRIBEBASESTATISTICSRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeBaseStatisticsResult : public ServiceResult
+			{
+			public:
+				struct BaseStatisticsItem
+				{
+					struct AgeItem
+					{
+						int count;
+						std::string name;
+					};
+					struct StayDistributionItem
+					{
+						long startTs;
+						long endTs;
+						int count;
+					};
+					struct AgeItem
+					{
+						int count;
+						std::string name;
+					};
+					struct AgeItem
+					{
+						int count;
+						std::string name;
+					};
+					std::vector<BaseStatisticsItem::AgeItem> ageItems;
+					std::vector<BaseStatisticsItem::StayDistributionItem> stayDistributionItems;
+					int maleUvCount;
+					long stayPeriod;
+					int femaleUvCount;
+					long locationId;
+					int newCount;
+					int onlyBodyUvCount;
+					std::string time;
+					std::vector<BaseStatisticsItem::AgeItem> femaleAgeItems;
+					int oldCount;
+					std::string summaryType;
+					long storeId;
+					std::vector<BaseStatisticsItem::AgeItem> maleAgeItems;
+					int uvCount;
+				};
+
+
+				DescribeBaseStatisticsResult();
+				explicit DescribeBaseStatisticsResult(const std::string &payload);
+				~DescribeBaseStatisticsResult();
+				std::string getCursorTime()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<BaseStatisticsItem> getBaseStatistics()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string cursorTime_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<BaseStatisticsItem> baseStatistics_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEBASESTATISTICSRESULT_H_

reid/include/alibabacloud/reid/model/DescribeCursorRequest.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_REID_MODEL_DESCRIBECURSORREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBECURSORREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeCursorRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCursorRequest();
+				~DescribeCursorRequest();
+
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				std::string getTime()const;
+				void setTime(const std::string& time);
+
+            private:
+				long storeId_;
+				std::string time_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECURSORREQUEST_H_

reid/include/alibabacloud/reid/model/DescribeCursorResult.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_REID_MODEL_DESCRIBECURSORRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBECURSORRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeCursorResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeCursorResult();
+				explicit DescribeCursorResult(const std::string &payload);
+				~DescribeCursorResult();
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::string getCursor()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::string cursor_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECURSORRESULT_H_

reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeCustomerFlowByLocationRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCustomerFlowByLocationRequest();
+				~DescribeCustomerFlowByLocationRequest();
+
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				long getMinCount()const;
+				void setMinCount(long minCount);
+				long getParentAmount()const;
+				void setParentAmount(long parentAmount);
+				long getMaxCount()const;
+				void setMaxCount(long maxCount);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				long getLocationId()const;
+				void setLocationId(long locationId);
+				std::string getParentLocationIds()const;
+				void setParentLocationIds(const std::string& parentLocationIds);
+
+            private:
+				std::string startDate_;
+				long storeId_;
+				long minCount_;
+				long parentAmount_;
+				long maxCount_;
+				std::string endDate_;
+				long locationId_;
+				std::string parentLocationIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONREQUEST_H_

reid/include/alibabacloud/reid/model/DescribeCustomerFlowByLocationResult.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeCustomerFlowByLocationResult : public ServiceResult
+			{
+			public:
+				struct CustomerFlowItem
+				{
+					long storeId;
+					float percent;
+					std::string parentLocationIds;
+					long locationId;
+					long count;
+					std::string locationName;
+				};
+
+
+				DescribeCustomerFlowByLocationResult();
+				explicit DescribeCustomerFlowByLocationResult(const std::string &payload);
+				~DescribeCustomerFlowByLocationResult();
+				std::vector<CustomerFlowItem> getCustomerFlowItems()const;
+				long getStoreId()const;
+				float getPercent()const;
+				long getLocationId()const;
+				std::string getParentLocationIds()const;
+				std::string getErrorCode()const;
+				long getCount()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+				std::string getLocationName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<CustomerFlowItem> customerFlowItems_;
+				long storeId_;
+				float percent_;
+				long locationId_;
+				std::string parentLocationIds_;
+				std::string errorCode_;
+				long count_;
+				std::string errorMessage_;
+				bool success_;
+				std::string locationName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBECUSTOMERFLOWBYLOCATIONRESULT_H_

reid/include/alibabacloud/reid/model/DescribeHeatMapRequest.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_REID_MODEL_DESCRIBEHEATMAPREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeHeatMapRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeHeatMapRequest();
+				~DescribeHeatMapRequest();
+
+				std::string getDate()const;
+				void setDate(const std::string& date);
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				long getEmapId()const;
+				void setEmapId(long emapId);
+
+            private:
+				std::string date_;
+				long storeId_;
+				long emapId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPREQUEST_H_

reid/include/alibabacloud/reid/model/DescribeHeatMapResult.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_REID_MODEL_DESCRIBEHEATMAPRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeHeatMapResult : public ServiceResult
+			{
+			public:
+				struct HeatMapPoint
+				{
+					float x;
+					float y;
+					int weight;
+				};
+
+
+				DescribeHeatMapResult();
+				explicit DescribeHeatMapResult(const std::string &payload);
+				~DescribeHeatMapResult();
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<HeatMapPoint> getHeatMapPoints()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<HeatMapPoint> heatMapPoints_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEHEATMAPRESULT_H_

reid/include/alibabacloud/reid/model/DescribeImageUrlsRequest.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_REID_MODEL_DESCRIBEIMAGEURLSREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeImageUrlsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeImageUrlsRequest();
+				~DescribeImageUrlsRequest();
+
+				std::string getOriginUrls()const;
+				void setOriginUrls(const std::string& originUrls);
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				std::string getObjectKeys()const;
+				void setObjectKeys(const std::string& objectKeys);
+
+            private:
+				std::string originUrls_;
+				long storeId_;
+				std::string objectKeys_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSREQUEST_H_

reid/include/alibabacloud/reid/model/DescribeImageUrlsResult.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_REID_MODEL_DESCRIBEIMAGEURLSRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeImageUrlsResult : public ServiceResult
+			{
+			public:
+				struct ImageUrl
+				{
+					std::string objectKey;
+					std::string url;
+				};
+
+
+				DescribeImageUrlsResult();
+				explicit DescribeImageUrlsResult(const std::string &payload);
+				~DescribeImageUrlsResult();
+				std::string getErrorCode()const;
+				std::vector<ImageUrl> getUrls()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errorCode_;
+				std::vector<ImageUrl> urls_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEIMAGEURLSRESULT_H_

reid/include/alibabacloud/reid/model/DescribeOverviewDataRequest.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_REID_MODEL_DESCRIBEOVERVIEWDATAREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeOverviewDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeOverviewDataRequest();
+				~DescribeOverviewDataRequest();
+
+				std::string getDate()const;
+				void setDate(const std::string& date);
+				std::string getStoreIds()const;
+				void setStoreIds(const std::string& storeIds);
+
+            private:
+				std::string date_;
+				std::string storeIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATAREQUEST_H_

reid/include/alibabacloud/reid/model/DescribeOverviewDataResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATARESULT_H_
+#define ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT DescribeOverviewDataResult : public ServiceResult
+			{
+			public:
+				struct OverviewDetail
+				{
+					float stayDeepAvg;
+					long uv;
+					float uvEverySqm;
+					float uvEverySqmGrowthWOWPercent;
+					float uvAvg;
+					float uvWOWPercent;
+					float stayAvgPeriod;
+					float stayDeepAvgWOWPercent;
+					float stayAvgPeriodWOWPercent;
+					float uvAvgWOWPercent;
+				};
+
+
+				DescribeOverviewDataResult();
+				explicit DescribeOverviewDataResult(const std::string &payload);
+				~DescribeOverviewDataResult();
+				OverviewDetail getOverviewDetail()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OverviewDetail overviewDetail_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_DESCRIBEOVERVIEWDATARESULT_H_

reid/include/alibabacloud/reid/model/ImportSpecialPersonnelRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ImportSpecialPersonnelRequest : public RpcServiceRequest
+			{
+
+			public:
+				ImportSpecialPersonnelRequest();
+				~ImportSpecialPersonnelRequest();
+
+				long getUkId()const;
+				void setUkId(long ukId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getExternalId()const;
+				void setExternalId(const std::string& externalId);
+				std::string getPersonType()const;
+				void setPersonType(const std::string& personType);
+				std::string getUrls()const;
+				void setUrls(const std::string& urls);
+				std::string getPersonName()const;
+				void setPersonName(const std::string& personName);
+				std::string getStoreIds()const;
+				void setStoreIds(const std::string& storeIds);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				long ukId_;
+				std::string description_;
+				std::string externalId_;
+				std::string personType_;
+				std::string urls_;
+				std::string personName_;
+				std::string storeIds_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELREQUEST_H_

reid/include/alibabacloud/reid/model/ImportSpecialPersonnelResult.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_REID_MODEL_IMPORTSPECIALPERSONNELRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ImportSpecialPersonnelResult : public ServiceResult
+			{
+			public:
+				struct SpecialPersonnelMap
+				{
+					long storeId;
+					long ukId;
+				};
+
+
+				ImportSpecialPersonnelResult();
+				explicit ImportSpecialPersonnelResult(const std::string &payload);
+				~ImportSpecialPersonnelResult();
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<SpecialPersonnelMap> getSpecialPersonnelMaps()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<SpecialPersonnelMap> specialPersonnelMaps_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_IMPORTSPECIALPERSONNELRESULT_H_

reid/include/alibabacloud/reid/model/ListActionDataRequest.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_REID_MODEL_LISTACTIONDATAREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_LISTACTIONDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListActionDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListActionDataRequest();
+				~ListActionDataRequest();
+
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				bool getFilterInvalidData()const;
+				void setFilterInvalidData(bool filterInvalidData);
+
+            private:
+				long endTime_;
+				long startTime_;
+				long storeId_;
+				int pageNumber_;
+				int pageSize_;
+				bool filterInvalidData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTACTIONDATAREQUEST_H_

reid/include/alibabacloud/reid/model/ListActionDataResult.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_REID_MODEL_LISTACTIONDATARESULT_H_
+#define ALIBABACLOUD_REID_MODEL_LISTACTIONDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListActionDataResult : public ServiceResult
+			{
+			public:
+				struct Action
+				{
+					struct ObjectPositionInImage
+					{
+						float left;
+						float top;
+						float right;
+						float bottom;
+					};
+					struct PointInMap
+					{
+						float x;
+						float y;
+					};
+					int status;
+					int facePointNumber;
+					int stayPeriod;
+					long leaveTimestamp;
+					long gmtModified;
+					long locationId;
+					std::string imageUrl;
+					std::string gender;
+					ObjectPositionInImage objectPositionInImage;
+					std::string imageType;
+					long arriveTimestamp;
+					long gmtCreate;
+					float score;
+					long storeId;
+					PointInMap pointInMap;
+					std::string locationLayerType;
+					std::string imageObjectKey;
+					long ukId;
+					long inStay;
+					std::string specialType;
+					bool stayValid;
+					long id;
+					int age;
+				};
+
+
+				ListActionDataResult();
+				explicit ListActionDataResult(const std::string &payload);
+				~ListActionDataResult();
+				long getTotalCount()const;
+				int getPageSize()const;
+				std::vector<Action> getActions()const;
+				int getPageNumber()const;
+				long getCursorTime()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				int pageSize_;
+				std::vector<Action> actions_;
+				int pageNumber_;
+				long cursorTime_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTACTIONDATARESULT_H_

reid/include/alibabacloud/reid/model/ListEmapRequest.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_REID_MODEL_LISTEMAPREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_LISTEMAPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListEmapRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListEmapRequest();
+				~ListEmapRequest();
+
+				long getStoreId()const;
+				void setStoreId(long storeId);
+
+            private:
+				long storeId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTEMAPREQUEST_H_

reid/include/alibabacloud/reid/model/ListEmapResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_REID_MODEL_LISTEMAPRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_LISTEMAPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListEmapResult : public ServiceResult
+			{
+			public:
+				struct OpenEmap
+				{
+					std::string emapUrl;
+					std::string locationId;
+					std::string emapId;
+					std::string name;
+				};
+
+
+				ListEmapResult();
+				explicit ListEmapResult(const std::string &payload);
+				~ListEmapResult();
+				std::vector<OpenEmap> getOpenEmaps()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<OpenEmap> openEmaps_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTEMAPRESULT_H_

reid/include/alibabacloud/reid/model/ListLocationRequest.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_REID_MODEL_LISTLOCATIONREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_LISTLOCATIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListLocationRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListLocationRequest();
+				~ListLocationRequest();
+
+				long getStoreId()const;
+				void setStoreId(long storeId);
+
+            private:
+				long storeId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTLOCATIONREQUEST_H_

reid/include/alibabacloud/reid/model/ListLocationResult.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_REID_MODEL_LISTLOCATIONRESULT_H_
+#define ALIBABACLOUD_REID_MODEL_LISTLOCATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListLocationResult : public ServiceResult
+			{
+			public:
+				struct LocationInfoItem
+				{
+					struct RectRoi
+					{
+						struct Point
+						{
+							float x;
+							float y;
+						};
+						std::vector<RectRoi::Point> points;
+					};
+					int status;
+					long gmtCreate;
+					std::vector<LocationInfoItem::RectRoi> rectRois;
+					long storeId;
+					long parentLocationId;
+					std::string externalId;
+					std::string layerType;
+					long gmtModified;
+					long locationId;
+					std::string locationType;
+					std::string locationName;
+				};
+
+
+				ListLocationResult();
+				explicit ListLocationResult(const std::string &payload);
+				~ListLocationResult();
+				std::vector<LocationInfoItem> getLocationInfoItems()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<LocationInfoItem> locationInfoItems_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTLOCATIONRESULT_H_

reid/include/alibabacloud/reid/model/ListPersonByImageRequest.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_REID_MODEL_LISTPERSONBYIMAGEREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListPersonByImageRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListPersonByImageRequest();
+				~ListPersonByImageRequest();
+
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				std::string getImageUrl()const;
+				void setImageUrl(const std::string& imageUrl);
+
+            private:
+				long storeId_;
+				std::string imageUrl_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGEREQUEST_H_

reid/include/alibabacloud/reid/model/ListPersonByImageResult.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_REID_MODEL_LISTPERSONBYIMAGERESULT_H_
+#define ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListPersonByImageResult : public ServiceResult
+			{
+			public:
+				struct PersonSearchResultItem
+				{
+					float score;
+					long ukId;
+				};
+
+
+				ListPersonByImageResult();
+				explicit ListPersonByImageResult(const std::string &payload);
+				~ListPersonByImageResult();
+				std::vector<PersonSearchResultItem> getPersonSearchResultItems()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PersonSearchResultItem> personSearchResultItems_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTPERSONBYIMAGERESULT_H_

reid/include/alibabacloud/reid/model/ListStoreRequest.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_REID_MODEL_LISTSTOREREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_LISTSTOREREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListStoreRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListStoreRequest();
+				~ListStoreRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTSTOREREQUEST_H_

reid/include/alibabacloud/reid/model/ListStoreResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_REID_MODEL_LISTSTORERESULT_H_
+#define ALIBABACLOUD_REID_MODEL_LISTSTORERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT ListStoreResult : public ServiceResult
+			{
+			public:
+				struct OpenStore
+				{
+					int status;
+					std::string storeType;
+					long gmtCreate;
+					std::string openingStartTime;
+					long storeId;
+					std::string address;
+					long gmtModified;
+					std::string openingEndTime;
+					float sqm;
+					std::string name;
+				};
+
+
+				ListStoreResult();
+				explicit ListStoreResult(const std::string &payload);
+				~ListStoreResult();
+				std::vector<OpenStore> getStores()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<OpenStore> stores_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_LISTSTORERESULT_H_

reid/include/alibabacloud/reid/model/PullActionDataRequest.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_REID_MODEL_PULLACTIONDATAREQUEST_H_
+#define ALIBABACLOUD_REID_MODEL_PULLACTIONDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT PullActionDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				PullActionDataRequest();
+				~PullActionDataRequest();
+
+				long getStoreId()const;
+				void setStoreId(long storeId);
+				long getEndMessageId()const;
+				void setEndMessageId(long endMessageId);
+				int getLimit()const;
+				void setLimit(int limit);
+				long getStartMessageId()const;
+				void setStartMessageId(long startMessageId);
+
+            private:
+				long storeId_;
+				long endMessageId_;
+				int limit_;
+				long startMessageId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_PULLACTIONDATAREQUEST_H_

reid/include/alibabacloud/reid/model/PullActionDataResult.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_REID_MODEL_PULLACTIONDATARESULT_H_
+#define ALIBABACLOUD_REID_MODEL_PULLACTIONDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/reid/ReidExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Reid
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_REID_EXPORT PullActionDataResult : public ServiceResult
+			{
+			public:
+				struct Action
+				{
+					struct ObjectPositionInImage
+					{
+						float left;
+						float top;
+						float right;
+						float bottom;
+					};
+					struct PointInMap
+					{
+						float x;
+						float y;
+					};
+					int status;
+					int facePointNumber;
+					int stayPeriod;
+					long leaveTimestamp;
+					long gmtModified;
+					long locationId;
+					std::string imageUrl;
+					std::string gender;
+					ObjectPositionInImage objectPositionInImage;
+					std::string imageType;
+					long arriveTimestamp;
+					long gmtCreate;
+					float score;
+					long storeId;
+					PointInMap pointInMap;
+					std::string locationLayerType;
+					std::string imageObjectKey;
+					long ukId;
+					long inStay;
+					std::string specialType;
+					bool stayValid;
+					long id;
+					int age;
+				};
+
+
+				PullActionDataResult();
+				explicit PullActionDataResult(const std::string &payload);
+				~PullActionDataResult();
+				std::vector<Action> getActions()const;
+				long getNextMessageId()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Action> actions_;
+				long nextMessageId_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_REID_MODEL_PULLACTIONDATARESULT_H_

reid/src/ReidClient.cc

@@ -0,0 +1,521 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/ReidClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "reid";
+}
+
+ReidClient::ReidClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "1.0.0");
+}
+
+ReidClient::ReidClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "1.0.0");
+}
+
+ReidClient::ReidClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "1.0.0");
+}
+
+ReidClient::~ReidClient()
+{}
+
+ReidClient::DescribeBaseStatisticsOutcome ReidClient::describeBaseStatistics(const DescribeBaseStatisticsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeBaseStatisticsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeBaseStatisticsOutcome(DescribeBaseStatisticsResult(outcome.result()));
+	else
+		return DescribeBaseStatisticsOutcome(outcome.error());
+}
+
+void ReidClient::describeBaseStatisticsAsync(const DescribeBaseStatisticsRequest& request, const DescribeBaseStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeBaseStatistics(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::DescribeBaseStatisticsOutcomeCallable ReidClient::describeBaseStatisticsCallable(const DescribeBaseStatisticsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeBaseStatisticsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeBaseStatistics(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::DescribeCursorOutcome ReidClient::describeCursor(const DescribeCursorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCursorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCursorOutcome(DescribeCursorResult(outcome.result()));
+	else
+		return DescribeCursorOutcome(outcome.error());
+}
+
+void ReidClient::describeCursorAsync(const DescribeCursorRequest& request, const DescribeCursorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCursor(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::DescribeCursorOutcomeCallable ReidClient::describeCursorCallable(const DescribeCursorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCursorOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCursor(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::DescribeCustomerFlowByLocationOutcome ReidClient::describeCustomerFlowByLocation(const DescribeCustomerFlowByLocationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCustomerFlowByLocationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCustomerFlowByLocationOutcome(DescribeCustomerFlowByLocationResult(outcome.result()));
+	else
+		return DescribeCustomerFlowByLocationOutcome(outcome.error());
+}
+
+void ReidClient::describeCustomerFlowByLocationAsync(const DescribeCustomerFlowByLocationRequest& request, const DescribeCustomerFlowByLocationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCustomerFlowByLocation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::DescribeCustomerFlowByLocationOutcomeCallable ReidClient::describeCustomerFlowByLocationCallable(const DescribeCustomerFlowByLocationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCustomerFlowByLocationOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCustomerFlowByLocation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::DescribeHeatMapOutcome ReidClient::describeHeatMap(const DescribeHeatMapRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeHeatMapOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeHeatMapOutcome(DescribeHeatMapResult(outcome.result()));
+	else
+		return DescribeHeatMapOutcome(outcome.error());
+}
+
+void ReidClient::describeHeatMapAsync(const DescribeHeatMapRequest& request, const DescribeHeatMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeHeatMap(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::DescribeHeatMapOutcomeCallable ReidClient::describeHeatMapCallable(const DescribeHeatMapRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeHeatMapOutcome()>>(
+			[this, request]()
+			{
+			return this->describeHeatMap(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::DescribeImageUrlsOutcome ReidClient::describeImageUrls(const DescribeImageUrlsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeImageUrlsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeImageUrlsOutcome(DescribeImageUrlsResult(outcome.result()));
+	else
+		return DescribeImageUrlsOutcome(outcome.error());
+}
+
+void ReidClient::describeImageUrlsAsync(const DescribeImageUrlsRequest& request, const DescribeImageUrlsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeImageUrls(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::DescribeImageUrlsOutcomeCallable ReidClient::describeImageUrlsCallable(const DescribeImageUrlsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeImageUrlsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeImageUrls(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::DescribeOverviewDataOutcome ReidClient::describeOverviewData(const DescribeOverviewDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeOverviewDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeOverviewDataOutcome(DescribeOverviewDataResult(outcome.result()));
+	else
+		return DescribeOverviewDataOutcome(outcome.error());
+}
+
+void ReidClient::describeOverviewDataAsync(const DescribeOverviewDataRequest& request, const DescribeOverviewDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeOverviewData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::DescribeOverviewDataOutcomeCallable ReidClient::describeOverviewDataCallable(const DescribeOverviewDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeOverviewDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeOverviewData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::ImportSpecialPersonnelOutcome ReidClient::importSpecialPersonnel(const ImportSpecialPersonnelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImportSpecialPersonnelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImportSpecialPersonnelOutcome(ImportSpecialPersonnelResult(outcome.result()));
+	else
+		return ImportSpecialPersonnelOutcome(outcome.error());
+}
+
+void ReidClient::importSpecialPersonnelAsync(const ImportSpecialPersonnelRequest& request, const ImportSpecialPersonnelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, importSpecialPersonnel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::ImportSpecialPersonnelOutcomeCallable ReidClient::importSpecialPersonnelCallable(const ImportSpecialPersonnelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImportSpecialPersonnelOutcome()>>(
+			[this, request]()
+			{
+			return this->importSpecialPersonnel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::ListActionDataOutcome ReidClient::listActionData(const ListActionDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListActionDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListActionDataOutcome(ListActionDataResult(outcome.result()));
+	else
+		return ListActionDataOutcome(outcome.error());
+}
+
+void ReidClient::listActionDataAsync(const ListActionDataRequest& request, const ListActionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listActionData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::ListActionDataOutcomeCallable ReidClient::listActionDataCallable(const ListActionDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListActionDataOutcome()>>(
+			[this, request]()
+			{
+			return this->listActionData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::ListEmapOutcome ReidClient::listEmap(const ListEmapRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListEmapOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListEmapOutcome(ListEmapResult(outcome.result()));
+	else
+		return ListEmapOutcome(outcome.error());
+}
+
+void ReidClient::listEmapAsync(const ListEmapRequest& request, const ListEmapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listEmap(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::ListEmapOutcomeCallable ReidClient::listEmapCallable(const ListEmapRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListEmapOutcome()>>(
+			[this, request]()
+			{
+			return this->listEmap(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::ListLocationOutcome ReidClient::listLocation(const ListLocationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListLocationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListLocationOutcome(ListLocationResult(outcome.result()));
+	else
+		return ListLocationOutcome(outcome.error());
+}
+
+void ReidClient::listLocationAsync(const ListLocationRequest& request, const ListLocationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listLocation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::ListLocationOutcomeCallable ReidClient::listLocationCallable(const ListLocationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListLocationOutcome()>>(
+			[this, request]()
+			{
+			return this->listLocation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::ListPersonByImageOutcome ReidClient::listPersonByImage(const ListPersonByImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPersonByImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPersonByImageOutcome(ListPersonByImageResult(outcome.result()));
+	else
+		return ListPersonByImageOutcome(outcome.error());
+}
+
+void ReidClient::listPersonByImageAsync(const ListPersonByImageRequest& request, const ListPersonByImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPersonByImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::ListPersonByImageOutcomeCallable ReidClient::listPersonByImageCallable(const ListPersonByImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPersonByImageOutcome()>>(
+			[this, request]()
+			{
+			return this->listPersonByImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::ListStoreOutcome ReidClient::listStore(const ListStoreRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListStoreOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListStoreOutcome(ListStoreResult(outcome.result()));
+	else
+		return ListStoreOutcome(outcome.error());
+}
+
+void ReidClient::listStoreAsync(const ListStoreRequest& request, const ListStoreAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listStore(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::ListStoreOutcomeCallable ReidClient::listStoreCallable(const ListStoreRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListStoreOutcome()>>(
+			[this, request]()
+			{
+			return this->listStore(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ReidClient::PullActionDataOutcome ReidClient::pullActionData(const PullActionDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PullActionDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PullActionDataOutcome(PullActionDataResult(outcome.result()));
+	else
+		return PullActionDataOutcome(outcome.error());
+}
+
+void ReidClient::pullActionDataAsync(const PullActionDataRequest& request, const PullActionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pullActionData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ReidClient::PullActionDataOutcomeCallable ReidClient::pullActionDataCallable(const PullActionDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PullActionDataOutcome()>>(
+			[this, request]()
+			{
+			return this->pullActionData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

reid/src/model/DescribeBaseStatisticsRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/reid/model/DescribeBaseStatisticsRequest.h>
+
+using AlibabaCloud::Reid::Model::DescribeBaseStatisticsRequest;
+
+DescribeBaseStatisticsRequest::DescribeBaseStatisticsRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "DescribeBaseStatistics")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeBaseStatisticsRequest::~DescribeBaseStatisticsRequest()
+{}
+
+std::string DescribeBaseStatisticsRequest::getDate()const
+{
+	return date_;
+}
+
+void DescribeBaseStatisticsRequest::setDate(const std::string& date)
+{
+	date_ = date;
+	setCoreParameter("Date", date);
+}
+
+std::string DescribeBaseStatisticsRequest::getExtraStatisticTypes()const
+{
+	return extraStatisticTypes_;
+}
+
+void DescribeBaseStatisticsRequest::setExtraStatisticTypes(const std::string& extraStatisticTypes)
+{
+	extraStatisticTypes_ = extraStatisticTypes;
+	setCoreParameter("ExtraStatisticTypes", extraStatisticTypes);
+}
+
+long DescribeBaseStatisticsRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void DescribeBaseStatisticsRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+std::string DescribeBaseStatisticsRequest::getSummaryType()const
+{
+	return summaryType_;
+}
+
+void DescribeBaseStatisticsRequest::setSummaryType(const std::string& summaryType)
+{
+	summaryType_ = summaryType;
+	setCoreParameter("SummaryType", summaryType);
+}
+
+long DescribeBaseStatisticsRequest::getLocationId()const
+{
+	return locationId_;
+}
+
+void DescribeBaseStatisticsRequest::setLocationId(long locationId)
+{
+	locationId_ = locationId;
+	setCoreParameter("LocationId", std::to_string(locationId));
+}
+

reid/src/model/DescribeBaseStatisticsResult.cc

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/DescribeBaseStatisticsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+DescribeBaseStatisticsResult::DescribeBaseStatisticsResult() :
+	ServiceResult()
+{}
+
+DescribeBaseStatisticsResult::DescribeBaseStatisticsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeBaseStatisticsResult::~DescribeBaseStatisticsResult()
+{}
+
+void DescribeBaseStatisticsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBaseStatisticsNode = value["BaseStatistics"]["BaseStatisticsItem"];
+	for (auto valueBaseStatisticsBaseStatisticsItem : allBaseStatisticsNode)
+	{
+		BaseStatisticsItem baseStatisticsObject;
+		if(!valueBaseStatisticsBaseStatisticsItem["StoreId"].isNull())
+			baseStatisticsObject.storeId = std::stol(valueBaseStatisticsBaseStatisticsItem["StoreId"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["FemaleUvCount"].isNull())
+			baseStatisticsObject.femaleUvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["FemaleUvCount"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["OldCount"].isNull())
+			baseStatisticsObject.oldCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["OldCount"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["NewCount"].isNull())
+			baseStatisticsObject.newCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["NewCount"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["SummaryType"].isNull())
+			baseStatisticsObject.summaryType = valueBaseStatisticsBaseStatisticsItem["SummaryType"].asString();
+		if(!valueBaseStatisticsBaseStatisticsItem["MaleUvCount"].isNull())
+			baseStatisticsObject.maleUvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["MaleUvCount"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["Time"].isNull())
+			baseStatisticsObject.time = valueBaseStatisticsBaseStatisticsItem["Time"].asString();
+		if(!valueBaseStatisticsBaseStatisticsItem["LocationId"].isNull())
+			baseStatisticsObject.locationId = std::stol(valueBaseStatisticsBaseStatisticsItem["LocationId"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["StayPeriod"].isNull())
+			baseStatisticsObject.stayPeriod = std::stol(valueBaseStatisticsBaseStatisticsItem["StayPeriod"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["UvCount"].isNull())
+			baseStatisticsObject.uvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["UvCount"].asString());
+		if(!valueBaseStatisticsBaseStatisticsItem["OnlyBodyUvCount"].isNull())
+			baseStatisticsObject.onlyBodyUvCount = std::stoi(valueBaseStatisticsBaseStatisticsItem["OnlyBodyUvCount"].asString());
+		auto allAgeItemsNode = allBaseStatisticsNode["AgeItems"]["AgeItem"];
+		for (auto allBaseStatisticsNodeAgeItemsAgeItem : allAgeItemsNode)
+		{
+			BaseStatisticsItem::AgeItem ageItemsObject;
+			if(!allBaseStatisticsNodeAgeItemsAgeItem["Name"].isNull())
+				ageItemsObject.name = allBaseStatisticsNodeAgeItemsAgeItem["Name"].asString();
+			if(!allBaseStatisticsNodeAgeItemsAgeItem["Count"].isNull())
+				ageItemsObject.count = std::stoi(allBaseStatisticsNodeAgeItemsAgeItem["Count"].asString());
+			baseStatisticsObject.ageItems.push_back(ageItemsObject);
+		}
+		auto allStayDistributionItemsNode = allBaseStatisticsNode["StayDistributionItems"]["StayDistributionItem"];
+		for (auto allBaseStatisticsNodeStayDistributionItemsStayDistributionItem : allStayDistributionItemsNode)
+		{
+			BaseStatisticsItem::StayDistributionItem stayDistributionItemsObject;
+			if(!allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["StartTs"].isNull())
+				stayDistributionItemsObject.startTs = std::stol(allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["StartTs"].asString());
+			if(!allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["EndTs"].isNull())
+				stayDistributionItemsObject.endTs = std::stol(allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["EndTs"].asString());
+			if(!allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["Count"].isNull())
+				stayDistributionItemsObject.count = std::stoi(allBaseStatisticsNodeStayDistributionItemsStayDistributionItem["Count"].asString());
+			baseStatisticsObject.stayDistributionItems.push_back(stayDistributionItemsObject);
+		}
+		auto allMaleAgeItemsNode = allBaseStatisticsNode["MaleAgeItems"]["AgeItem"];
+		for (auto allBaseStatisticsNodeMaleAgeItemsAgeItem : allMaleAgeItemsNode)
+		{
+			BaseStatisticsItem::AgeItem maleAgeItemsObject;
+			if(!allBaseStatisticsNodeMaleAgeItemsAgeItem["Name"].isNull())
+				maleAgeItemsObject.name = allBaseStatisticsNodeMaleAgeItemsAgeItem["Name"].asString();
+			if(!allBaseStatisticsNodeMaleAgeItemsAgeItem["Count"].isNull())
+				maleAgeItemsObject.count = std::stoi(allBaseStatisticsNodeMaleAgeItemsAgeItem["Count"].asString());
+			baseStatisticsObject.maleAgeItems.push_back(maleAgeItemsObject);
+		}
+		auto allFemaleAgeItemsNode = allBaseStatisticsNode["FemaleAgeItems"]["AgeItem"];
+		for (auto allBaseStatisticsNodeFemaleAgeItemsAgeItem : allFemaleAgeItemsNode)
+		{
+			BaseStatisticsItem::AgeItem femaleAgeItemsObject;
+			if(!allBaseStatisticsNodeFemaleAgeItemsAgeItem["Name"].isNull())
+				femaleAgeItemsObject.name = allBaseStatisticsNodeFemaleAgeItemsAgeItem["Name"].asString();
+			if(!allBaseStatisticsNodeFemaleAgeItemsAgeItem["Count"].isNull())
+				femaleAgeItemsObject.count = std::stoi(allBaseStatisticsNodeFemaleAgeItemsAgeItem["Count"].asString());
+			baseStatisticsObject.femaleAgeItems.push_back(femaleAgeItemsObject);
+		}
+		baseStatistics_.push_back(baseStatisticsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["CursorTime"].isNull())
+		cursorTime_ = value["CursorTime"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string DescribeBaseStatisticsResult::getCursorTime()const
+{
+	return cursorTime_;
+}
+
+std::string DescribeBaseStatisticsResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DescribeBaseStatisticsResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<DescribeBaseStatisticsResult::BaseStatisticsItem> DescribeBaseStatisticsResult::getBaseStatistics()const
+{
+	return baseStatistics_;
+}
+
+bool DescribeBaseStatisticsResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/DescribeCursorRequest.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/reid/model/DescribeCursorRequest.h>
+
+using AlibabaCloud::Reid::Model::DescribeCursorRequest;
+
+DescribeCursorRequest::DescribeCursorRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "DescribeCursor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCursorRequest::~DescribeCursorRequest()
+{}
+
+long DescribeCursorRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void DescribeCursorRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+std::string DescribeCursorRequest::getTime()const
+{
+	return time_;
+}
+
+void DescribeCursorRequest::setTime(const std::string& time)
+{
+	time_ = time;
+	setCoreParameter("Time", time);
+}
+

reid/src/model/DescribeCursorResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/reid/model/DescribeCursorResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+DescribeCursorResult::DescribeCursorResult() :
+	ServiceResult()
+{}
+
+DescribeCursorResult::DescribeCursorResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCursorResult::~DescribeCursorResult()
+{}
+
+void DescribeCursorResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Cursor"].isNull())
+		cursor_ = value["Cursor"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string DescribeCursorResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DescribeCursorResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::string DescribeCursorResult::getCursor()const
+{
+	return cursor_;
+}
+
+bool DescribeCursorResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/DescribeCustomerFlowByLocationRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/DescribeCustomerFlowByLocationRequest.h>
+
+using AlibabaCloud::Reid::Model::DescribeCustomerFlowByLocationRequest;
+
+DescribeCustomerFlowByLocationRequest::DescribeCustomerFlowByLocationRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "DescribeCustomerFlowByLocation")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCustomerFlowByLocationRequest::~DescribeCustomerFlowByLocationRequest()
+{}
+
+std::string DescribeCustomerFlowByLocationRequest::getStartDate()const
+{
+	return startDate_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setStartDate(const std::string& startDate)
+{
+	startDate_ = startDate;
+	setCoreParameter("StartDate", startDate);
+}
+
+long DescribeCustomerFlowByLocationRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+long DescribeCustomerFlowByLocationRequest::getMinCount()const
+{
+	return minCount_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setMinCount(long minCount)
+{
+	minCount_ = minCount;
+	setCoreParameter("MinCount", std::to_string(minCount));
+}
+
+long DescribeCustomerFlowByLocationRequest::getParentAmount()const
+{
+	return parentAmount_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setParentAmount(long parentAmount)
+{
+	parentAmount_ = parentAmount;
+	setCoreParameter("ParentAmount", std::to_string(parentAmount));
+}
+
+long DescribeCustomerFlowByLocationRequest::getMaxCount()const
+{
+	return maxCount_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setMaxCount(long maxCount)
+{
+	maxCount_ = maxCount;
+	setCoreParameter("MaxCount", std::to_string(maxCount));
+}
+
+std::string DescribeCustomerFlowByLocationRequest::getEndDate()const
+{
+	return endDate_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setEndDate(const std::string& endDate)
+{
+	endDate_ = endDate;
+	setCoreParameter("EndDate", endDate);
+}
+
+long DescribeCustomerFlowByLocationRequest::getLocationId()const
+{
+	return locationId_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setLocationId(long locationId)
+{
+	locationId_ = locationId;
+	setCoreParameter("LocationId", std::to_string(locationId));
+}
+
+std::string DescribeCustomerFlowByLocationRequest::getParentLocationIds()const
+{
+	return parentLocationIds_;
+}
+
+void DescribeCustomerFlowByLocationRequest::setParentLocationIds(const std::string& parentLocationIds)
+{
+	parentLocationIds_ = parentLocationIds;
+	setCoreParameter("ParentLocationIds", parentLocationIds);
+}
+

reid/src/model/DescribeCustomerFlowByLocationResult.cc

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/DescribeCustomerFlowByLocationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+DescribeCustomerFlowByLocationResult::DescribeCustomerFlowByLocationResult() :
+	ServiceResult()
+{}
+
+DescribeCustomerFlowByLocationResult::DescribeCustomerFlowByLocationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCustomerFlowByLocationResult::~DescribeCustomerFlowByLocationResult()
+{}
+
+void DescribeCustomerFlowByLocationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCustomerFlowItemsNode = value["CustomerFlowItems"]["CustomerFlowItem"];
+	for (auto valueCustomerFlowItemsCustomerFlowItem : allCustomerFlowItemsNode)
+	{
+		CustomerFlowItem customerFlowItemsObject;
+		if(!valueCustomerFlowItemsCustomerFlowItem["Count"].isNull())
+			customerFlowItemsObject.count = std::stol(valueCustomerFlowItemsCustomerFlowItem["Count"].asString());
+		if(!valueCustomerFlowItemsCustomerFlowItem["StoreId"].isNull())
+			customerFlowItemsObject.storeId = std::stol(valueCustomerFlowItemsCustomerFlowItem["StoreId"].asString());
+		if(!valueCustomerFlowItemsCustomerFlowItem["Percent"].isNull())
+			customerFlowItemsObject.percent = std::stof(valueCustomerFlowItemsCustomerFlowItem["Percent"].asString());
+		if(!valueCustomerFlowItemsCustomerFlowItem["LocationName"].isNull())
+			customerFlowItemsObject.locationName = valueCustomerFlowItemsCustomerFlowItem["LocationName"].asString();
+		if(!valueCustomerFlowItemsCustomerFlowItem["ParentLocationIds"].isNull())
+			customerFlowItemsObject.parentLocationIds = valueCustomerFlowItemsCustomerFlowItem["ParentLocationIds"].asString();
+		if(!valueCustomerFlowItemsCustomerFlowItem["LocationId"].isNull())
+			customerFlowItemsObject.locationId = std::stol(valueCustomerFlowItemsCustomerFlowItem["LocationId"].asString());
+		customerFlowItems_.push_back(customerFlowItemsObject);
+	}
+	if(!value["LocationId"].isNull())
+		locationId_ = std::stol(value["LocationId"].asString());
+	if(!value["ParentLocationIds"].isNull())
+		parentLocationIds_ = value["ParentLocationIds"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["LocationName"].isNull())
+		locationName_ = value["LocationName"].asString();
+	if(!value["Percent"].isNull())
+		percent_ = std::stof(value["Percent"].asString());
+	if(!value["StoreId"].isNull())
+		storeId_ = std::stol(value["StoreId"].asString());
+	if(!value["Count"].isNull())
+		count_ = std::stol(value["Count"].asString());
+
+}
+
+std::vector<DescribeCustomerFlowByLocationResult::CustomerFlowItem> DescribeCustomerFlowByLocationResult::getCustomerFlowItems()const
+{
+	return customerFlowItems_;
+}
+
+long DescribeCustomerFlowByLocationResult::getStoreId()const
+{
+	return storeId_;
+}
+
+float DescribeCustomerFlowByLocationResult::getPercent()const
+{
+	return percent_;
+}
+
+long DescribeCustomerFlowByLocationResult::getLocationId()const
+{
+	return locationId_;
+}
+
+std::string DescribeCustomerFlowByLocationResult::getParentLocationIds()const
+{
+	return parentLocationIds_;
+}
+
+std::string DescribeCustomerFlowByLocationResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+long DescribeCustomerFlowByLocationResult::getCount()const
+{
+	return count_;
+}
+
+std::string DescribeCustomerFlowByLocationResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool DescribeCustomerFlowByLocationResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string DescribeCustomerFlowByLocationResult::getLocationName()const
+{
+	return locationName_;
+}
+

reid/src/model/DescribeHeatMapRequest.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/reid/model/DescribeHeatMapRequest.h>
+
+using AlibabaCloud::Reid::Model::DescribeHeatMapRequest;
+
+DescribeHeatMapRequest::DescribeHeatMapRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "DescribeHeatMap")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeHeatMapRequest::~DescribeHeatMapRequest()
+{}
+
+std::string DescribeHeatMapRequest::getDate()const
+{
+	return date_;
+}
+
+void DescribeHeatMapRequest::setDate(const std::string& date)
+{
+	date_ = date;
+	setCoreParameter("Date", date);
+}
+
+long DescribeHeatMapRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void DescribeHeatMapRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+long DescribeHeatMapRequest::getEmapId()const
+{
+	return emapId_;
+}
+
+void DescribeHeatMapRequest::setEmapId(long emapId)
+{
+	emapId_ = emapId;
+	setCoreParameter("EmapId", std::to_string(emapId));
+}
+

reid/src/model/DescribeHeatMapResult.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/reid/model/DescribeHeatMapResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+DescribeHeatMapResult::DescribeHeatMapResult() :
+	ServiceResult()
+{}
+
+DescribeHeatMapResult::DescribeHeatMapResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeHeatMapResult::~DescribeHeatMapResult()
+{}
+
+void DescribeHeatMapResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allHeatMapPointsNode = value["HeatMapPoints"]["HeatMapPoint"];
+	for (auto valueHeatMapPointsHeatMapPoint : allHeatMapPointsNode)
+	{
+		HeatMapPoint heatMapPointsObject;
+		if(!valueHeatMapPointsHeatMapPoint["Y"].isNull())
+			heatMapPointsObject.y = std::stof(valueHeatMapPointsHeatMapPoint["Y"].asString());
+		if(!valueHeatMapPointsHeatMapPoint["Weight"].isNull())
+			heatMapPointsObject.weight = std::stoi(valueHeatMapPointsHeatMapPoint["Weight"].asString());
+		if(!valueHeatMapPointsHeatMapPoint["X"].isNull())
+			heatMapPointsObject.x = std::stof(valueHeatMapPointsHeatMapPoint["X"].asString());
+		heatMapPoints_.push_back(heatMapPointsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string DescribeHeatMapResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DescribeHeatMapResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<DescribeHeatMapResult::HeatMapPoint> DescribeHeatMapResult::getHeatMapPoints()const
+{
+	return heatMapPoints_;
+}
+
+bool DescribeHeatMapResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/DescribeImageUrlsRequest.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/reid/model/DescribeImageUrlsRequest.h>
+
+using AlibabaCloud::Reid::Model::DescribeImageUrlsRequest;
+
+DescribeImageUrlsRequest::DescribeImageUrlsRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "DescribeImageUrls")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeImageUrlsRequest::~DescribeImageUrlsRequest()
+{}
+
+std::string DescribeImageUrlsRequest::getOriginUrls()const
+{
+	return originUrls_;
+}
+
+void DescribeImageUrlsRequest::setOriginUrls(const std::string& originUrls)
+{
+	originUrls_ = originUrls;
+	setCoreParameter("OriginUrls", originUrls);
+}
+
+long DescribeImageUrlsRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void DescribeImageUrlsRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+std::string DescribeImageUrlsRequest::getObjectKeys()const
+{
+	return objectKeys_;
+}
+
+void DescribeImageUrlsRequest::setObjectKeys(const std::string& objectKeys)
+{
+	objectKeys_ = objectKeys;
+	setCoreParameter("ObjectKeys", objectKeys);
+}
+

reid/src/model/DescribeImageUrlsResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/reid/model/DescribeImageUrlsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+DescribeImageUrlsResult::DescribeImageUrlsResult() :
+	ServiceResult()
+{}
+
+DescribeImageUrlsResult::DescribeImageUrlsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeImageUrlsResult::~DescribeImageUrlsResult()
+{}
+
+void DescribeImageUrlsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allUrlsNode = value["Urls"]["ImageUrl"];
+	for (auto valueUrlsImageUrl : allUrlsNode)
+	{
+		ImageUrl urlsObject;
+		if(!valueUrlsImageUrl["ObjectKey"].isNull())
+			urlsObject.objectKey = valueUrlsImageUrl["ObjectKey"].asString();
+		if(!valueUrlsImageUrl["Url"].isNull())
+			urlsObject.url = valueUrlsImageUrl["Url"].asString();
+		urls_.push_back(urlsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string DescribeImageUrlsResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::vector<DescribeImageUrlsResult::ImageUrl> DescribeImageUrlsResult::getUrls()const
+{
+	return urls_;
+}
+
+std::string DescribeImageUrlsResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool DescribeImageUrlsResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/DescribeOverviewDataRequest.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/reid/model/DescribeOverviewDataRequest.h>
+
+using AlibabaCloud::Reid::Model::DescribeOverviewDataRequest;
+
+DescribeOverviewDataRequest::DescribeOverviewDataRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "DescribeOverviewData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeOverviewDataRequest::~DescribeOverviewDataRequest()
+{}
+
+std::string DescribeOverviewDataRequest::getDate()const
+{
+	return date_;
+}
+
+void DescribeOverviewDataRequest::setDate(const std::string& date)
+{
+	date_ = date;
+	setCoreParameter("Date", date);
+}
+
+std::string DescribeOverviewDataRequest::getStoreIds()const
+{
+	return storeIds_;
+}
+
+void DescribeOverviewDataRequest::setStoreIds(const std::string& storeIds)
+{
+	storeIds_ = storeIds;
+	setCoreParameter("StoreIds", storeIds);
+}
+

reid/src/model/DescribeOverviewDataResult.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/DescribeOverviewDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+DescribeOverviewDataResult::DescribeOverviewDataResult() :
+	ServiceResult()
+{}
+
+DescribeOverviewDataResult::DescribeOverviewDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeOverviewDataResult::~DescribeOverviewDataResult()
+{}
+
+void DescribeOverviewDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto overviewDetailNode = value["OverviewDetail"];
+	if(!overviewDetailNode["StayDeepAvgWOWPercent"].isNull())
+		overviewDetail_.stayDeepAvgWOWPercent = std::stof(overviewDetailNode["StayDeepAvgWOWPercent"].asString());
+	if(!overviewDetailNode["StayDeepAvg"].isNull())
+		overviewDetail_.stayDeepAvg = std::stof(overviewDetailNode["StayDeepAvg"].asString());
+	if(!overviewDetailNode["UvAvgWOWPercent"].isNull())
+		overviewDetail_.uvAvgWOWPercent = std::stof(overviewDetailNode["UvAvgWOWPercent"].asString());
+	if(!overviewDetailNode["StayAvgPeriodWOWPercent"].isNull())
+		overviewDetail_.stayAvgPeriodWOWPercent = std::stof(overviewDetailNode["StayAvgPeriodWOWPercent"].asString());
+	if(!overviewDetailNode["UvEverySqmGrowthWOWPercent"].isNull())
+		overviewDetail_.uvEverySqmGrowthWOWPercent = std::stof(overviewDetailNode["UvEverySqmGrowthWOWPercent"].asString());
+	if(!overviewDetailNode["UvWOWPercent"].isNull())
+		overviewDetail_.uvWOWPercent = std::stof(overviewDetailNode["UvWOWPercent"].asString());
+	if(!overviewDetailNode["Uv"].isNull())
+		overviewDetail_.uv = std::stol(overviewDetailNode["Uv"].asString());
+	if(!overviewDetailNode["UvEverySqm"].isNull())
+		overviewDetail_.uvEverySqm = std::stof(overviewDetailNode["UvEverySqm"].asString());
+	if(!overviewDetailNode["UvAvg"].isNull())
+		overviewDetail_.uvAvg = std::stof(overviewDetailNode["UvAvg"].asString());
+	if(!overviewDetailNode["StayAvgPeriod"].isNull())
+		overviewDetail_.stayAvgPeriod = std::stof(overviewDetailNode["StayAvgPeriod"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+DescribeOverviewDataResult::OverviewDetail DescribeOverviewDataResult::getOverviewDetail()const
+{
+	return overviewDetail_;
+}
+
+std::string DescribeOverviewDataResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DescribeOverviewDataResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool DescribeOverviewDataResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/ImportSpecialPersonnelRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/ImportSpecialPersonnelRequest.h>
+
+using AlibabaCloud::Reid::Model::ImportSpecialPersonnelRequest;
+
+ImportSpecialPersonnelRequest::ImportSpecialPersonnelRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "ImportSpecialPersonnel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ImportSpecialPersonnelRequest::~ImportSpecialPersonnelRequest()
+{}
+
+long ImportSpecialPersonnelRequest::getUkId()const
+{
+	return ukId_;
+}
+
+void ImportSpecialPersonnelRequest::setUkId(long ukId)
+{
+	ukId_ = ukId;
+	setCoreParameter("UkId", std::to_string(ukId));
+}
+
+std::string ImportSpecialPersonnelRequest::getDescription()const
+{
+	return description_;
+}
+
+void ImportSpecialPersonnelRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setCoreParameter("Description", description);
+}
+
+std::string ImportSpecialPersonnelRequest::getExternalId()const
+{
+	return externalId_;
+}
+
+void ImportSpecialPersonnelRequest::setExternalId(const std::string& externalId)
+{
+	externalId_ = externalId;
+	setCoreParameter("ExternalId", externalId);
+}
+
+std::string ImportSpecialPersonnelRequest::getPersonType()const
+{
+	return personType_;
+}
+
+void ImportSpecialPersonnelRequest::setPersonType(const std::string& personType)
+{
+	personType_ = personType;
+	setCoreParameter("PersonType", personType);
+}
+
+std::string ImportSpecialPersonnelRequest::getUrls()const
+{
+	return urls_;
+}
+
+void ImportSpecialPersonnelRequest::setUrls(const std::string& urls)
+{
+	urls_ = urls;
+	setCoreParameter("Urls", urls);
+}
+
+std::string ImportSpecialPersonnelRequest::getPersonName()const
+{
+	return personName_;
+}
+
+void ImportSpecialPersonnelRequest::setPersonName(const std::string& personName)
+{
+	personName_ = personName;
+	setCoreParameter("PersonName", personName);
+}
+
+std::string ImportSpecialPersonnelRequest::getStoreIds()const
+{
+	return storeIds_;
+}
+
+void ImportSpecialPersonnelRequest::setStoreIds(const std::string& storeIds)
+{
+	storeIds_ = storeIds;
+	setCoreParameter("StoreIds", storeIds);
+}
+
+std::string ImportSpecialPersonnelRequest::getStatus()const
+{
+	return status_;
+}
+
+void ImportSpecialPersonnelRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setCoreParameter("Status", status);
+}
+

reid/src/model/ImportSpecialPersonnelResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/reid/model/ImportSpecialPersonnelResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+ImportSpecialPersonnelResult::ImportSpecialPersonnelResult() :
+	ServiceResult()
+{}
+
+ImportSpecialPersonnelResult::ImportSpecialPersonnelResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ImportSpecialPersonnelResult::~ImportSpecialPersonnelResult()
+{}
+
+void ImportSpecialPersonnelResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSpecialPersonnelMapsNode = value["SpecialPersonnelMaps"]["SpecialPersonnelMap"];
+	for (auto valueSpecialPersonnelMapsSpecialPersonnelMap : allSpecialPersonnelMapsNode)
+	{
+		SpecialPersonnelMap specialPersonnelMapsObject;
+		if(!valueSpecialPersonnelMapsSpecialPersonnelMap["UkId"].isNull())
+			specialPersonnelMapsObject.ukId = std::stol(valueSpecialPersonnelMapsSpecialPersonnelMap["UkId"].asString());
+		if(!valueSpecialPersonnelMapsSpecialPersonnelMap["StoreId"].isNull())
+			specialPersonnelMapsObject.storeId = std::stol(valueSpecialPersonnelMapsSpecialPersonnelMap["StoreId"].asString());
+		specialPersonnelMaps_.push_back(specialPersonnelMapsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ImportSpecialPersonnelResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ImportSpecialPersonnelResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<ImportSpecialPersonnelResult::SpecialPersonnelMap> ImportSpecialPersonnelResult::getSpecialPersonnelMaps()const
+{
+	return specialPersonnelMaps_;
+}
+
+bool ImportSpecialPersonnelResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/ListActionDataRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/reid/model/ListActionDataRequest.h>
+
+using AlibabaCloud::Reid::Model::ListActionDataRequest;
+
+ListActionDataRequest::ListActionDataRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "ListActionData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListActionDataRequest::~ListActionDataRequest()
+{}
+
+long ListActionDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void ListActionDataRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setCoreParameter("EndTime", std::to_string(endTime));
+}
+
+long ListActionDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void ListActionDataRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setCoreParameter("StartTime", std::to_string(startTime));
+}
+
+long ListActionDataRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void ListActionDataRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+int ListActionDataRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListActionDataRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setCoreParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListActionDataRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListActionDataRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setCoreParameter("PageSize", std::to_string(pageSize));
+}
+
+bool ListActionDataRequest::getFilterInvalidData()const
+{
+	return filterInvalidData_;
+}
+
+void ListActionDataRequest::setFilterInvalidData(bool filterInvalidData)
+{
+	filterInvalidData_ = filterInvalidData;
+	setCoreParameter("FilterInvalidData", filterInvalidData ? "true" : "false");
+}
+

reid/src/model/ListActionDataResult.cc

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/ListActionDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+ListActionDataResult::ListActionDataResult() :
+	ServiceResult()
+{}
+
+ListActionDataResult::ListActionDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListActionDataResult::~ListActionDataResult()
+{}
+
+void ListActionDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allActionsNode = value["Actions"]["Action"];
+	for (auto valueActionsAction : allActionsNode)
+	{
+		Action actionsObject;
+		if(!valueActionsAction["StoreId"].isNull())
+			actionsObject.storeId = std::stol(valueActionsAction["StoreId"].asString());
+		if(!valueActionsAction["GmtCreate"].isNull())
+			actionsObject.gmtCreate = std::stol(valueActionsAction["GmtCreate"].asString());
+		if(!valueActionsAction["LeaveTimestamp"].isNull())
+			actionsObject.leaveTimestamp = std::stol(valueActionsAction["LeaveTimestamp"].asString());
+		if(!valueActionsAction["LocationLayerType"].isNull())
+			actionsObject.locationLayerType = valueActionsAction["LocationLayerType"].asString();
+		if(!valueActionsAction["StayValid"].isNull())
+			actionsObject.stayValid = valueActionsAction["StayValid"].asString() == "true";
+		if(!valueActionsAction["Gender"].isNull())
+			actionsObject.gender = valueActionsAction["Gender"].asString();
+		if(!valueActionsAction["UkId"].isNull())
+			actionsObject.ukId = std::stol(valueActionsAction["UkId"].asString());
+		if(!valueActionsAction["ArriveTimestamp"].isNull())
+			actionsObject.arriveTimestamp = std::stol(valueActionsAction["ArriveTimestamp"].asString());
+		if(!valueActionsAction["GmtModified"].isNull())
+			actionsObject.gmtModified = std::stol(valueActionsAction["GmtModified"].asString());
+		if(!valueActionsAction["ImageType"].isNull())
+			actionsObject.imageType = valueActionsAction["ImageType"].asString();
+		if(!valueActionsAction["InStay"].isNull())
+			actionsObject.inStay = std::stol(valueActionsAction["InStay"].asString());
+		if(!valueActionsAction["Status"].isNull())
+			actionsObject.status = std::stoi(valueActionsAction["Status"].asString());
+		if(!valueActionsAction["Age"].isNull())
+			actionsObject.age = std::stoi(valueActionsAction["Age"].asString());
+		if(!valueActionsAction["Id"].isNull())
+			actionsObject.id = std::stol(valueActionsAction["Id"].asString());
+		if(!valueActionsAction["ImageUrl"].isNull())
+			actionsObject.imageUrl = valueActionsAction["ImageUrl"].asString();
+		if(!valueActionsAction["LocationId"].isNull())
+			actionsObject.locationId = std::stol(valueActionsAction["LocationId"].asString());
+		if(!valueActionsAction["StayPeriod"].isNull())
+			actionsObject.stayPeriod = std::stoi(valueActionsAction["StayPeriod"].asString());
+		if(!valueActionsAction["Score"].isNull())
+			actionsObject.score = std::stof(valueActionsAction["Score"].asString());
+		if(!valueActionsAction["SpecialType"].isNull())
+			actionsObject.specialType = valueActionsAction["SpecialType"].asString();
+		if(!valueActionsAction["ImageObjectKey"].isNull())
+			actionsObject.imageObjectKey = valueActionsAction["ImageObjectKey"].asString();
+		if(!valueActionsAction["FacePointNumber"].isNull())
+			actionsObject.facePointNumber = std::stoi(valueActionsAction["FacePointNumber"].asString());
+		auto objectPositionInImageNode = value["ObjectPositionInImage"];
+		if(!objectPositionInImageNode["Bottom"].isNull())
+			actionsObject.objectPositionInImage.bottom = std::stof(objectPositionInImageNode["Bottom"].asString());
+		if(!objectPositionInImageNode["Left"].isNull())
+			actionsObject.objectPositionInImage.left = std::stof(objectPositionInImageNode["Left"].asString());
+		if(!objectPositionInImageNode["Top"].isNull())
+			actionsObject.objectPositionInImage.top = std::stof(objectPositionInImageNode["Top"].asString());
+		if(!objectPositionInImageNode["Right"].isNull())
+			actionsObject.objectPositionInImage.right = std::stof(objectPositionInImageNode["Right"].asString());
+		auto pointInMapNode = value["PointInMap"];
+		if(!pointInMapNode["X"].isNull())
+			actionsObject.pointInMap.x = std::stof(pointInMapNode["X"].asString());
+		if(!pointInMapNode["Y"].isNull())
+			actionsObject.pointInMap.y = std::stof(pointInMapNode["Y"].asString());
+		actions_.push_back(actionsObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["CursorTime"].isNull())
+		cursorTime_ = std::stol(value["CursorTime"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+long ListActionDataResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListActionDataResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+std::vector<ListActionDataResult::Action> ListActionDataResult::getActions()const
+{
+	return actions_;
+}
+
+int ListActionDataResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+long ListActionDataResult::getCursorTime()const
+{
+	return cursorTime_;
+}
+
+std::string ListActionDataResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListActionDataResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListActionDataResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/ListEmapRequest.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/reid/model/ListEmapRequest.h>
+
+using AlibabaCloud::Reid::Model::ListEmapRequest;
+
+ListEmapRequest::ListEmapRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "ListEmap")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListEmapRequest::~ListEmapRequest()
+{}
+
+long ListEmapRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void ListEmapRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+

reid/src/model/ListEmapResult.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/reid/model/ListEmapResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+ListEmapResult::ListEmapResult() :
+	ServiceResult()
+{}
+
+ListEmapResult::ListEmapResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListEmapResult::~ListEmapResult()
+{}
+
+void ListEmapResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allOpenEmapsNode = value["OpenEmaps"]["OpenEmap"];
+	for (auto valueOpenEmapsOpenEmap : allOpenEmapsNode)
+	{
+		OpenEmap openEmapsObject;
+		if(!valueOpenEmapsOpenEmap["LocationId"].isNull())
+			openEmapsObject.locationId = valueOpenEmapsOpenEmap["LocationId"].asString();
+		if(!valueOpenEmapsOpenEmap["EmapId"].isNull())
+			openEmapsObject.emapId = valueOpenEmapsOpenEmap["EmapId"].asString();
+		if(!valueOpenEmapsOpenEmap["Name"].isNull())
+			openEmapsObject.name = valueOpenEmapsOpenEmap["Name"].asString();
+		if(!valueOpenEmapsOpenEmap["EmapUrl"].isNull())
+			openEmapsObject.emapUrl = valueOpenEmapsOpenEmap["EmapUrl"].asString();
+		openEmaps_.push_back(openEmapsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::vector<ListEmapResult::OpenEmap> ListEmapResult::getOpenEmaps()const
+{
+	return openEmaps_;
+}
+
+std::string ListEmapResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListEmapResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListEmapResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/ListLocationRequest.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/reid/model/ListLocationRequest.h>
+
+using AlibabaCloud::Reid::Model::ListLocationRequest;
+
+ListLocationRequest::ListLocationRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "ListLocation")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListLocationRequest::~ListLocationRequest()
+{}
+
+long ListLocationRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void ListLocationRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+

reid/src/model/ListLocationResult.cc

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/ListLocationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+ListLocationResult::ListLocationResult() :
+	ServiceResult()
+{}
+
+ListLocationResult::ListLocationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListLocationResult::~ListLocationResult()
+{}
+
+void ListLocationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLocationInfoItemsNode = value["LocationInfoItems"]["LocationInfoItem"];
+	for (auto valueLocationInfoItemsLocationInfoItem : allLocationInfoItemsNode)
+	{
+		LocationInfoItem locationInfoItemsObject;
+		if(!valueLocationInfoItemsLocationInfoItem["ExternalId"].isNull())
+			locationInfoItemsObject.externalId = valueLocationInfoItemsLocationInfoItem["ExternalId"].asString();
+		if(!valueLocationInfoItemsLocationInfoItem["LocationType"].isNull())
+			locationInfoItemsObject.locationType = valueLocationInfoItemsLocationInfoItem["LocationType"].asString();
+		if(!valueLocationInfoItemsLocationInfoItem["Status"].isNull())
+			locationInfoItemsObject.status = std::stoi(valueLocationInfoItemsLocationInfoItem["Status"].asString());
+		if(!valueLocationInfoItemsLocationInfoItem["StoreId"].isNull())
+			locationInfoItemsObject.storeId = std::stol(valueLocationInfoItemsLocationInfoItem["StoreId"].asString());
+		if(!valueLocationInfoItemsLocationInfoItem["GmtCreate"].isNull())
+			locationInfoItemsObject.gmtCreate = std::stol(valueLocationInfoItemsLocationInfoItem["GmtCreate"].asString());
+		if(!valueLocationInfoItemsLocationInfoItem["ParentLocationId"].isNull())
+			locationInfoItemsObject.parentLocationId = std::stol(valueLocationInfoItemsLocationInfoItem["ParentLocationId"].asString());
+		if(!valueLocationInfoItemsLocationInfoItem["GmtModified"].isNull())
+			locationInfoItemsObject.gmtModified = std::stol(valueLocationInfoItemsLocationInfoItem["GmtModified"].asString());
+		if(!valueLocationInfoItemsLocationInfoItem["LocationName"].isNull())
+			locationInfoItemsObject.locationName = valueLocationInfoItemsLocationInfoItem["LocationName"].asString();
+		if(!valueLocationInfoItemsLocationInfoItem["LayerType"].isNull())
+			locationInfoItemsObject.layerType = valueLocationInfoItemsLocationInfoItem["LayerType"].asString();
+		if(!valueLocationInfoItemsLocationInfoItem["LocationId"].isNull())
+			locationInfoItemsObject.locationId = std::stol(valueLocationInfoItemsLocationInfoItem["LocationId"].asString());
+		auto allRectRoisNode = allLocationInfoItemsNode["RectRois"]["RectRoi"];
+		for (auto allLocationInfoItemsNodeRectRoisRectRoi : allRectRoisNode)
+		{
+			LocationInfoItem::RectRoi rectRoisObject;
+			auto allPointsNode = allRectRoisNode["Points"]["Point"];
+			for (auto allRectRoisNodePointsPoint : allPointsNode)
+			{
+				LocationInfoItem::RectRoi::Point pointsObject;
+				if(!allRectRoisNodePointsPoint["X"].isNull())
+					pointsObject.x = std::stof(allRectRoisNodePointsPoint["X"].asString());
+				if(!allRectRoisNodePointsPoint["Y"].isNull())
+					pointsObject.y = std::stof(allRectRoisNodePointsPoint["Y"].asString());
+				rectRoisObject.points.push_back(pointsObject);
+			}
+			locationInfoItemsObject.rectRois.push_back(rectRoisObject);
+		}
+		locationInfoItems_.push_back(locationInfoItemsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::vector<ListLocationResult::LocationInfoItem> ListLocationResult::getLocationInfoItems()const
+{
+	return locationInfoItems_;
+}
+
+std::string ListLocationResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListLocationResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListLocationResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/ListPersonByImageRequest.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/reid/model/ListPersonByImageRequest.h>
+
+using AlibabaCloud::Reid::Model::ListPersonByImageRequest;
+
+ListPersonByImageRequest::ListPersonByImageRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "ListPersonByImage")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListPersonByImageRequest::~ListPersonByImageRequest()
+{}
+
+long ListPersonByImageRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void ListPersonByImageRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+std::string ListPersonByImageRequest::getImageUrl()const
+{
+	return imageUrl_;
+}
+
+void ListPersonByImageRequest::setImageUrl(const std::string& imageUrl)
+{
+	imageUrl_ = imageUrl;
+	setCoreParameter("ImageUrl", imageUrl);
+}
+

reid/src/model/ListPersonByImageResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/reid/model/ListPersonByImageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+ListPersonByImageResult::ListPersonByImageResult() :
+	ServiceResult()
+{}
+
+ListPersonByImageResult::ListPersonByImageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListPersonByImageResult::~ListPersonByImageResult()
+{}
+
+void ListPersonByImageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPersonSearchResultItemsNode = value["PersonSearchResultItems"]["PersonSearchResultItem"];
+	for (auto valuePersonSearchResultItemsPersonSearchResultItem : allPersonSearchResultItemsNode)
+	{
+		PersonSearchResultItem personSearchResultItemsObject;
+		if(!valuePersonSearchResultItemsPersonSearchResultItem["UkId"].isNull())
+			personSearchResultItemsObject.ukId = std::stol(valuePersonSearchResultItemsPersonSearchResultItem["UkId"].asString());
+		if(!valuePersonSearchResultItemsPersonSearchResultItem["Score"].isNull())
+			personSearchResultItemsObject.score = std::stof(valuePersonSearchResultItemsPersonSearchResultItem["Score"].asString());
+		personSearchResultItems_.push_back(personSearchResultItemsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::vector<ListPersonByImageResult::PersonSearchResultItem> ListPersonByImageResult::getPersonSearchResultItems()const
+{
+	return personSearchResultItems_;
+}
+
+std::string ListPersonByImageResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListPersonByImageResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListPersonByImageResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/ListStoreRequest.cc

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/ListStoreRequest.h>
+
+using AlibabaCloud::Reid::Model::ListStoreRequest;
+
+ListStoreRequest::ListStoreRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "ListStore")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListStoreRequest::~ListStoreRequest()
+{}
+

reid/src/model/ListStoreResult.cc

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/ListStoreResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+ListStoreResult::ListStoreResult() :
+	ServiceResult()
+{}
+
+ListStoreResult::ListStoreResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListStoreResult::~ListStoreResult()
+{}
+
+void ListStoreResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allStoresNode = value["Stores"]["OpenStore"];
+	for (auto valueStoresOpenStore : allStoresNode)
+	{
+		OpenStore storesObject;
+		if(!valueStoresOpenStore["StoreId"].isNull())
+			storesObject.storeId = std::stol(valueStoresOpenStore["StoreId"].asString());
+		if(!valueStoresOpenStore["GmtCreate"].isNull())
+			storesObject.gmtCreate = std::stol(valueStoresOpenStore["GmtCreate"].asString());
+		if(!valueStoresOpenStore["Sqm"].isNull())
+			storesObject.sqm = std::stof(valueStoresOpenStore["Sqm"].asString());
+		if(!valueStoresOpenStore["Status"].isNull())
+			storesObject.status = std::stoi(valueStoresOpenStore["Status"].asString());
+		if(!valueStoresOpenStore["Name"].isNull())
+			storesObject.name = valueStoresOpenStore["Name"].asString();
+		if(!valueStoresOpenStore["OpeningEndTime"].isNull())
+			storesObject.openingEndTime = valueStoresOpenStore["OpeningEndTime"].asString();
+		if(!valueStoresOpenStore["OpeningStartTime"].isNull())
+			storesObject.openingStartTime = valueStoresOpenStore["OpeningStartTime"].asString();
+		if(!valueStoresOpenStore["StoreType"].isNull())
+			storesObject.storeType = valueStoresOpenStore["StoreType"].asString();
+		if(!valueStoresOpenStore["GmtModified"].isNull())
+			storesObject.gmtModified = std::stol(valueStoresOpenStore["GmtModified"].asString());
+		if(!valueStoresOpenStore["Address"].isNull())
+			storesObject.address = valueStoresOpenStore["Address"].asString();
+		stores_.push_back(storesObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::vector<ListStoreResult::OpenStore> ListStoreResult::getStores()const
+{
+	return stores_;
+}
+
+std::string ListStoreResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListStoreResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListStoreResult::getSuccess()const
+{
+	return success_;
+}
+

reid/src/model/PullActionDataRequest.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/reid/model/PullActionDataRequest.h>
+
+using AlibabaCloud::Reid::Model::PullActionDataRequest;
+
+PullActionDataRequest::PullActionDataRequest() :
+	RpcServiceRequest("reid", "2019-09-28", "PullActionData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PullActionDataRequest::~PullActionDataRequest()
+{}
+
+long PullActionDataRequest::getStoreId()const
+{
+	return storeId_;
+}
+
+void PullActionDataRequest::setStoreId(long storeId)
+{
+	storeId_ = storeId;
+	setCoreParameter("StoreId", std::to_string(storeId));
+}
+
+long PullActionDataRequest::getEndMessageId()const
+{
+	return endMessageId_;
+}
+
+void PullActionDataRequest::setEndMessageId(long endMessageId)
+{
+	endMessageId_ = endMessageId;
+	setCoreParameter("EndMessageId", std::to_string(endMessageId));
+}
+
+int PullActionDataRequest::getLimit()const
+{
+	return limit_;
+}
+
+void PullActionDataRequest::setLimit(int limit)
+{
+	limit_ = limit;
+	setCoreParameter("Limit", std::to_string(limit));
+}
+
+long PullActionDataRequest::getStartMessageId()const
+{
+	return startMessageId_;
+}
+
+void PullActionDataRequest::setStartMessageId(long startMessageId)
+{
+	startMessageId_ = startMessageId;
+	setCoreParameter("StartMessageId", std::to_string(startMessageId));
+}
+

reid/src/model/PullActionDataResult.cc

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/reid/model/PullActionDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Reid;
+using namespace AlibabaCloud::Reid::Model;
+
+PullActionDataResult::PullActionDataResult() :
+	ServiceResult()
+{}
+
+PullActionDataResult::PullActionDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PullActionDataResult::~PullActionDataResult()
+{}
+
+void PullActionDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allActionsNode = value["Actions"]["Action"];
+	for (auto valueActionsAction : allActionsNode)
+	{
+		Action actionsObject;
+		if(!valueActionsAction["StoreId"].isNull())
+			actionsObject.storeId = std::stol(valueActionsAction["StoreId"].asString());
+		if(!valueActionsAction["GmtCreate"].isNull())
+			actionsObject.gmtCreate = std::stol(valueActionsAction["GmtCreate"].asString());
+		if(!valueActionsAction["LeaveTimestamp"].isNull())
+			actionsObject.leaveTimestamp = std::stol(valueActionsAction["LeaveTimestamp"].asString());
+		if(!valueActionsAction["LocationLayerType"].isNull())
+			actionsObject.locationLayerType = valueActionsAction["LocationLayerType"].asString();
+		if(!valueActionsAction["StayValid"].isNull())
+			actionsObject.stayValid = valueActionsAction["StayValid"].asString() == "true";
+		if(!valueActionsAction["Gender"].isNull())
+			actionsObject.gender = valueActionsAction["Gender"].asString();
+		if(!valueActionsAction["UkId"].isNull())
+			actionsObject.ukId = std::stol(valueActionsAction["UkId"].asString());
+		if(!valueActionsAction["ArriveTimestamp"].isNull())
+			actionsObject.arriveTimestamp = std::stol(valueActionsAction["ArriveTimestamp"].asString());
+		if(!valueActionsAction["GmtModified"].isNull())
+			actionsObject.gmtModified = std::stol(valueActionsAction["GmtModified"].asString());
+		if(!valueActionsAction["ImageType"].isNull())
+			actionsObject.imageType = valueActionsAction["ImageType"].asString();
+		if(!valueActionsAction["InStay"].isNull())
+			actionsObject.inStay = std::stol(valueActionsAction["InStay"].asString());
+		if(!valueActionsAction["Status"].isNull())
+			actionsObject.status = std::stoi(valueActionsAction["Status"].asString());
+		if(!valueActionsAction["Age"].isNull())
+			actionsObject.age = std::stoi(valueActionsAction["Age"].asString());
+		if(!valueActionsAction["Id"].isNull())
+			actionsObject.id = std::stol(valueActionsAction["Id"].asString());
+		if(!valueActionsAction["ImageUrl"].isNull())
+			actionsObject.imageUrl = valueActionsAction["ImageUrl"].asString();
+		if(!valueActionsAction["LocationId"].isNull())
+			actionsObject.locationId = std::stol(valueActionsAction["LocationId"].asString());
+		if(!valueActionsAction["StayPeriod"].isNull())
+			actionsObject.stayPeriod = std::stoi(valueActionsAction["StayPeriod"].asString());
+		if(!valueActionsAction["Score"].isNull())
+			actionsObject.score = std::stof(valueActionsAction["Score"].asString());
+		if(!valueActionsAction["SpecialType"].isNull())
+			actionsObject.specialType = valueActionsAction["SpecialType"].asString();
+		if(!valueActionsAction["ImageObjectKey"].isNull())
+			actionsObject.imageObjectKey = valueActionsAction["ImageObjectKey"].asString();
+		if(!valueActionsAction["FacePointNumber"].isNull())
+			actionsObject.facePointNumber = std::stoi(valueActionsAction["FacePointNumber"].asString());
+		auto objectPositionInImageNode = value["ObjectPositionInImage"];
+		if(!objectPositionInImageNode["Bottom"].isNull())
+			actionsObject.objectPositionInImage.bottom = std::stof(objectPositionInImageNode["Bottom"].asString());
+		if(!objectPositionInImageNode["Left"].isNull())
+			actionsObject.objectPositionInImage.left = std::stof(objectPositionInImageNode["Left"].asString());
+		if(!objectPositionInImageNode["Top"].isNull())
+			actionsObject.objectPositionInImage.top = std::stof(objectPositionInImageNode["Top"].asString());
+		if(!objectPositionInImageNode["Right"].isNull())
+			actionsObject.objectPositionInImage.right = std::stof(objectPositionInImageNode["Right"].asString());
+		auto pointInMapNode = value["PointInMap"];
+		if(!pointInMapNode["X"].isNull())
+			actionsObject.pointInMap.x = std::stof(pointInMapNode["X"].asString());
+		if(!pointInMapNode["Y"].isNull())
+			actionsObject.pointInMap.y = std::stof(pointInMapNode["Y"].asString());
+		actions_.push_back(actionsObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["NextMessageId"].isNull())
+		nextMessageId_ = std::stol(value["NextMessageId"].asString());
+
+}
+
+std::vector<PullActionDataResult::Action> PullActionDataResult::getActions()const
+{
+	return actions_;
+}
+
+long PullActionDataResult::getNextMessageId()const
+{
+	return nextMessageId_;
+}
+
+std::string PullActionDataResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string PullActionDataResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool PullActionDataResult::getSuccess()const
+{
+	return success_;
+}
+