Add monitor related.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-05-25 Version: 1.36.430
+- Add monitor related.
+
 2020-05-23 Version: 1.36.429
 - Generated 2015-01-01 for `R-kvstore`.
 - Add ModifyResourceGroup API.

VERSION

@@ -1 +1 @@
-1.36.429
+1.36.430

vcs/CMakeLists.txt

@@ -23,51 +23,83 @@ set(vcs_public_header
 set(vcs_public_header_model 
 	include/alibabacloud/vcs/model/AddDeviceRequest.h
 	include/alibabacloud/vcs/model/AddDeviceResult.h
+	include/alibabacloud/vcs/model/AddMonitorRequest.h
+	include/alibabacloud/vcs/model/AddMonitorResult.h
 	include/alibabacloud/vcs/model/CreateCorpRequest.h
 	include/alibabacloud/vcs/model/CreateCorpResult.h
 	include/alibabacloud/vcs/model/DeleteDeviceRequest.h
 	include/alibabacloud/vcs/model/DeleteDeviceResult.h
+	include/alibabacloud/vcs/model/GetBodyOptionsRequest.h
+	include/alibabacloud/vcs/model/GetBodyOptionsResult.h
 	include/alibabacloud/vcs/model/GetDeviceLiveUrlRequest.h
 	include/alibabacloud/vcs/model/GetDeviceLiveUrlResult.h
+	include/alibabacloud/vcs/model/GetDeviceVideoUrlRequest.h
+	include/alibabacloud/vcs/model/GetDeviceVideoUrlResult.h
+	include/alibabacloud/vcs/model/GetFaceOptionsRequest.h
+	include/alibabacloud/vcs/model/GetFaceOptionsResult.h
 	include/alibabacloud/vcs/model/GetInventoryRequest.h
 	include/alibabacloud/vcs/model/GetInventoryResult.h
+	include/alibabacloud/vcs/model/GetMonitorResultRequest.h
+	include/alibabacloud/vcs/model/GetMonitorResultResult.h
 	include/alibabacloud/vcs/model/ListCorpsRequest.h
 	include/alibabacloud/vcs/model/ListCorpsResult.h
 	include/alibabacloud/vcs/model/ListDevicesRequest.h
 	include/alibabacloud/vcs/model/ListDevicesResult.h
 	include/alibabacloud/vcs/model/RecognizeImageRequest.h
 	include/alibabacloud/vcs/model/RecognizeImageResult.h
+	include/alibabacloud/vcs/model/SearchBodyRequest.h
+	include/alibabacloud/vcs/model/SearchBodyResult.h
 	include/alibabacloud/vcs/model/SearchFaceRequest.h
 	include/alibabacloud/vcs/model/SearchFaceResult.h
+	include/alibabacloud/vcs/model/StopMonitorRequest.h
+	include/alibabacloud/vcs/model/StopMonitorResult.h
 	include/alibabacloud/vcs/model/UpdateCorpRequest.h
 	include/alibabacloud/vcs/model/UpdateCorpResult.h
 	include/alibabacloud/vcs/model/UpdateDeviceRequest.h
-	include/alibabacloud/vcs/model/UpdateDeviceResult.h )
+	include/alibabacloud/vcs/model/UpdateDeviceResult.h
+	include/alibabacloud/vcs/model/UpdateMonitorRequest.h
+	include/alibabacloud/vcs/model/UpdateMonitorResult.h )
 
 set(vcs_src 
 	src/VcsClient.cc
 	src/model/AddDeviceRequest.cc
 	src/model/AddDeviceResult.cc
+	src/model/AddMonitorRequest.cc
+	src/model/AddMonitorResult.cc
 	src/model/CreateCorpRequest.cc
 	src/model/CreateCorpResult.cc
 	src/model/DeleteDeviceRequest.cc
 	src/model/DeleteDeviceResult.cc
+	src/model/GetBodyOptionsRequest.cc
+	src/model/GetBodyOptionsResult.cc
 	src/model/GetDeviceLiveUrlRequest.cc
 	src/model/GetDeviceLiveUrlResult.cc
+	src/model/GetDeviceVideoUrlRequest.cc
+	src/model/GetDeviceVideoUrlResult.cc
+	src/model/GetFaceOptionsRequest.cc
+	src/model/GetFaceOptionsResult.cc
 	src/model/GetInventoryRequest.cc
 	src/model/GetInventoryResult.cc
+	src/model/GetMonitorResultRequest.cc
+	src/model/GetMonitorResultResult.cc
 	src/model/ListCorpsRequest.cc
 	src/model/ListCorpsResult.cc
 	src/model/ListDevicesRequest.cc
 	src/model/ListDevicesResult.cc
 	src/model/RecognizeImageRequest.cc
 	src/model/RecognizeImageResult.cc
+	src/model/SearchBodyRequest.cc
+	src/model/SearchBodyResult.cc
 	src/model/SearchFaceRequest.cc
 	src/model/SearchFaceResult.cc
+	src/model/StopMonitorRequest.cc
+	src/model/StopMonitorResult.cc
 	src/model/UpdateCorpRequest.cc
 	src/model/UpdateCorpResult.cc
 	src/model/UpdateDeviceRequest.cc
-	src/model/UpdateDeviceResult.cc )
+	src/model/UpdateDeviceResult.cc
+	src/model/UpdateMonitorRequest.cc
+	src/model/UpdateMonitorResult.cc )
 
 add_library(vcs ${LIB_TYPE}
 	${vcs_public_header}

vcs/include/alibabacloud/vcs/VcsClient.h

@@ -24,26 +24,42 @@
 #include "VcsExport.h"
 #include "model/AddDeviceRequest.h"
 #include "model/AddDeviceResult.h"
+#include "model/AddMonitorRequest.h"
+#include "model/AddMonitorResult.h"
 #include "model/CreateCorpRequest.h"
 #include "model/CreateCorpResult.h"
 #include "model/DeleteDeviceRequest.h"
 #include "model/DeleteDeviceResult.h"
+#include "model/GetBodyOptionsRequest.h"
+#include "model/GetBodyOptionsResult.h"
 #include "model/GetDeviceLiveUrlRequest.h"
 #include "model/GetDeviceLiveUrlResult.h"
+#include "model/GetDeviceVideoUrlRequest.h"
+#include "model/GetDeviceVideoUrlResult.h"
+#include "model/GetFaceOptionsRequest.h"
+#include "model/GetFaceOptionsResult.h"
 #include "model/GetInventoryRequest.h"
 #include "model/GetInventoryResult.h"
+#include "model/GetMonitorResultRequest.h"
+#include "model/GetMonitorResultResult.h"
 #include "model/ListCorpsRequest.h"
 #include "model/ListCorpsResult.h"
 #include "model/ListDevicesRequest.h"
 #include "model/ListDevicesResult.h"
 #include "model/RecognizeImageRequest.h"
 #include "model/RecognizeImageResult.h"
+#include "model/SearchBodyRequest.h"
+#include "model/SearchBodyResult.h"
 #include "model/SearchFaceRequest.h"
 #include "model/SearchFaceResult.h"
+#include "model/StopMonitorRequest.h"
+#include "model/StopMonitorResult.h"
 #include "model/UpdateCorpRequest.h"
 #include "model/UpdateCorpResult.h"
 #include "model/UpdateDeviceRequest.h"
 #include "model/UpdateDeviceResult.h"
+#include "model/UpdateMonitorRequest.h"
+#include "model/UpdateMonitorResult.h"
 
 
 namespace AlibabaCloud
@@ -56,18 +72,33 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddDeviceResult> AddDeviceOutcome;
 			typedef std::future<AddDeviceOutcome> AddDeviceOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::AddDeviceRequest&, const AddDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDeviceAsyncHandler;
+			typedef Outcome<Error, Model::AddMonitorResult> AddMonitorOutcome;
+			typedef std::future<AddMonitorOutcome> AddMonitorOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::AddMonitorRequest&, const AddMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddMonitorAsyncHandler;
 			typedef Outcome<Error, Model::CreateCorpResult> CreateCorpOutcome;
 			typedef std::future<CreateCorpOutcome> CreateCorpOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::CreateCorpRequest&, const CreateCorpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCorpAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDeviceResult> DeleteDeviceOutcome;
 			typedef std::future<DeleteDeviceOutcome> DeleteDeviceOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::DeleteDeviceRequest&, const DeleteDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDeviceAsyncHandler;
+			typedef Outcome<Error, Model::GetBodyOptionsResult> GetBodyOptionsOutcome;
+			typedef std::future<GetBodyOptionsOutcome> GetBodyOptionsOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::GetBodyOptionsRequest&, const GetBodyOptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBodyOptionsAsyncHandler;
 			typedef Outcome<Error, Model::GetDeviceLiveUrlResult> GetDeviceLiveUrlOutcome;
 			typedef std::future<GetDeviceLiveUrlOutcome> GetDeviceLiveUrlOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::GetDeviceLiveUrlRequest&, const GetDeviceLiveUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDeviceLiveUrlAsyncHandler;
+			typedef Outcome<Error, Model::GetDeviceVideoUrlResult> GetDeviceVideoUrlOutcome;
+			typedef std::future<GetDeviceVideoUrlOutcome> GetDeviceVideoUrlOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::GetDeviceVideoUrlRequest&, const GetDeviceVideoUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDeviceVideoUrlAsyncHandler;
+			typedef Outcome<Error, Model::GetFaceOptionsResult> GetFaceOptionsOutcome;
+			typedef std::future<GetFaceOptionsOutcome> GetFaceOptionsOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::GetFaceOptionsRequest&, const GetFaceOptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFaceOptionsAsyncHandler;
 			typedef Outcome<Error, Model::GetInventoryResult> GetInventoryOutcome;
 			typedef std::future<GetInventoryOutcome> GetInventoryOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::GetInventoryRequest&, const GetInventoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInventoryAsyncHandler;
+			typedef Outcome<Error, Model::GetMonitorResultResult> GetMonitorResultOutcome;
+			typedef std::future<GetMonitorResultOutcome> GetMonitorResultOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::GetMonitorResultRequest&, const GetMonitorResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMonitorResultAsyncHandler;
 			typedef Outcome<Error, Model::ListCorpsResult> ListCorpsOutcome;
 			typedef std::future<ListCorpsOutcome> ListCorpsOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::ListCorpsRequest&, const ListCorpsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCorpsAsyncHandler;
@@ -77,15 +108,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RecognizeImageResult> RecognizeImageOutcome;
 			typedef std::future<RecognizeImageOutcome> RecognizeImageOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::RecognizeImageRequest&, const RecognizeImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeImageAsyncHandler;
+			typedef Outcome<Error, Model::SearchBodyResult> SearchBodyOutcome;
+			typedef std::future<SearchBodyOutcome> SearchBodyOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::SearchBodyRequest&, const SearchBodyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchBodyAsyncHandler;
 			typedef Outcome<Error, Model::SearchFaceResult> SearchFaceOutcome;
 			typedef std::future<SearchFaceOutcome> SearchFaceOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::SearchFaceRequest&, const SearchFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchFaceAsyncHandler;
+			typedef Outcome<Error, Model::StopMonitorResult> StopMonitorOutcome;
+			typedef std::future<StopMonitorOutcome> StopMonitorOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::StopMonitorRequest&, const StopMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopMonitorAsyncHandler;
 			typedef Outcome<Error, Model::UpdateCorpResult> UpdateCorpOutcome;
 			typedef std::future<UpdateCorpOutcome> UpdateCorpOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::UpdateCorpRequest&, const UpdateCorpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCorpAsyncHandler;
 			typedef Outcome<Error, Model::UpdateDeviceResult> UpdateDeviceOutcome;
 			typedef std::future<UpdateDeviceOutcome> UpdateDeviceOutcomeCallable;
 			typedef std::function<void(const VcsClient*, const Model::UpdateDeviceRequest&, const UpdateDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDeviceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateMonitorResult> UpdateMonitorOutcome;
+			typedef std::future<UpdateMonitorOutcome> UpdateMonitorOutcomeCallable;
+			typedef std::function<void(const VcsClient*, const Model::UpdateMonitorRequest&, const UpdateMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMonitorAsyncHandler;
 
 			VcsClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			VcsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -94,18 +134,33 @@ namespace AlibabaCloud
 			AddDeviceOutcome addDevice(const Model::AddDeviceRequest &request)const;
 			void addDeviceAsync(const Model::AddDeviceRequest& request, const AddDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddDeviceOutcomeCallable addDeviceCallable(const Model::AddDeviceRequest& request) const;
+			AddMonitorOutcome addMonitor(const Model::AddMonitorRequest &request)const;
+			void addMonitorAsync(const Model::AddMonitorRequest& request, const AddMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddMonitorOutcomeCallable addMonitorCallable(const Model::AddMonitorRequest& request) const;
 			CreateCorpOutcome createCorp(const Model::CreateCorpRequest &request)const;
 			void createCorpAsync(const Model::CreateCorpRequest& request, const CreateCorpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCorpOutcomeCallable createCorpCallable(const Model::CreateCorpRequest& request) const;
 			DeleteDeviceOutcome deleteDevice(const Model::DeleteDeviceRequest &request)const;
 			void deleteDeviceAsync(const Model::DeleteDeviceRequest& request, const DeleteDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDeviceOutcomeCallable deleteDeviceCallable(const Model::DeleteDeviceRequest& request) const;
+			GetBodyOptionsOutcome getBodyOptions(const Model::GetBodyOptionsRequest &request)const;
+			void getBodyOptionsAsync(const Model::GetBodyOptionsRequest& request, const GetBodyOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetBodyOptionsOutcomeCallable getBodyOptionsCallable(const Model::GetBodyOptionsRequest& request) const;
 			GetDeviceLiveUrlOutcome getDeviceLiveUrl(const Model::GetDeviceLiveUrlRequest &request)const;
 			void getDeviceLiveUrlAsync(const Model::GetDeviceLiveUrlRequest& request, const GetDeviceLiveUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDeviceLiveUrlOutcomeCallable getDeviceLiveUrlCallable(const Model::GetDeviceLiveUrlRequest& request) const;
+			GetDeviceVideoUrlOutcome getDeviceVideoUrl(const Model::GetDeviceVideoUrlRequest &request)const;
+			void getDeviceVideoUrlAsync(const Model::GetDeviceVideoUrlRequest& request, const GetDeviceVideoUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDeviceVideoUrlOutcomeCallable getDeviceVideoUrlCallable(const Model::GetDeviceVideoUrlRequest& request) const;
+			GetFaceOptionsOutcome getFaceOptions(const Model::GetFaceOptionsRequest &request)const;
+			void getFaceOptionsAsync(const Model::GetFaceOptionsRequest& request, const GetFaceOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetFaceOptionsOutcomeCallable getFaceOptionsCallable(const Model::GetFaceOptionsRequest& request) const;
 			GetInventoryOutcome getInventory(const Model::GetInventoryRequest &request)const;
 			void getInventoryAsync(const Model::GetInventoryRequest& request, const GetInventoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetInventoryOutcomeCallable getInventoryCallable(const Model::GetInventoryRequest& request) const;
+			GetMonitorResultOutcome getMonitorResult(const Model::GetMonitorResultRequest &request)const;
+			void getMonitorResultAsync(const Model::GetMonitorResultRequest& request, const GetMonitorResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMonitorResultOutcomeCallable getMonitorResultCallable(const Model::GetMonitorResultRequest& request) const;
 			ListCorpsOutcome listCorps(const Model::ListCorpsRequest &request)const;
 			void listCorpsAsync(const Model::ListCorpsRequest& request, const ListCorpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListCorpsOutcomeCallable listCorpsCallable(const Model::ListCorpsRequest& request) const;
@@ -115,15 +170,24 @@ namespace AlibabaCloud
 			RecognizeImageOutcome recognizeImage(const Model::RecognizeImageRequest &request)const;
 			void recognizeImageAsync(const Model::RecognizeImageRequest& request, const RecognizeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RecognizeImageOutcomeCallable recognizeImageCallable(const Model::RecognizeImageRequest& request) const;
+			SearchBodyOutcome searchBody(const Model::SearchBodyRequest &request)const;
+			void searchBodyAsync(const Model::SearchBodyRequest& request, const SearchBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchBodyOutcomeCallable searchBodyCallable(const Model::SearchBodyRequest& request) const;
 			SearchFaceOutcome searchFace(const Model::SearchFaceRequest &request)const;
 			void searchFaceAsync(const Model::SearchFaceRequest& request, const SearchFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SearchFaceOutcomeCallable searchFaceCallable(const Model::SearchFaceRequest& request) const;
+			StopMonitorOutcome stopMonitor(const Model::StopMonitorRequest &request)const;
+			void stopMonitorAsync(const Model::StopMonitorRequest& request, const StopMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopMonitorOutcomeCallable stopMonitorCallable(const Model::StopMonitorRequest& request) const;
 			UpdateCorpOutcome updateCorp(const Model::UpdateCorpRequest &request)const;
 			void updateCorpAsync(const Model::UpdateCorpRequest& request, const UpdateCorpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateCorpOutcomeCallable updateCorpCallable(const Model::UpdateCorpRequest& request) const;
 			UpdateDeviceOutcome updateDevice(const Model::UpdateDeviceRequest &request)const;
 			void updateDeviceAsync(const Model::UpdateDeviceRequest& request, const UpdateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateDeviceOutcomeCallable updateDeviceCallable(const Model::UpdateDeviceRequest& request) const;
+			UpdateMonitorOutcome updateMonitor(const Model::UpdateMonitorRequest &request)const;
+			void updateMonitorAsync(const Model::UpdateMonitorRequest& request, const UpdateMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateMonitorOutcomeCallable updateMonitorCallable(const Model::UpdateMonitorRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

vcs/include/alibabacloud/vcs/model/AddDeviceRequest.h

@@ -41,10 +41,10 @@ namespace AlibabaCloud
 				void setCorpId(const std::string& corpId);
 				std::string getGbId()const;
 				void setGbId(const std::string& gbId);
+				std::string getBitRate()const;
+				void setBitRate(const std::string& bitRate);
 				std::string getDeviceDirection()const;
 				void setDeviceDirection(const std::string& deviceDirection);
-				std::string getDeviceRate()const;
-				void setDeviceRate(const std::string& deviceRate);
 				std::string getDeviceAddress()const;
 				void setDeviceAddress(const std::string& deviceAddress);
 				std::string getDeviceType()const;
@@ -60,8 +60,8 @@ namespace AlibabaCloud
 				std::string deviceSite_;
 				std::string corpId_;
 				std::string gbId_;
+				std::string bitRate_;
 				std::string deviceDirection_;
-				std::string deviceRate_;
 				std::string deviceAddress_;
 				std::string deviceType_;
 				std::string deviceResolution_;

vcs/include/alibabacloud/vcs/model/AddMonitorRequest.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_VCS_MODEL_ADDMONITORREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_ADDMONITORREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT AddMonitorRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddMonitorRequest();
+				~AddMonitorRequest();
+
+				std::string getMonitorType()const;
+				void setMonitorType(const std::string& monitorType);
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				int getBatchIndicator()const;
+				void setBatchIndicator(int batchIndicator);
+
+            private:
+				std::string monitorType_;
+				std::string corpId_;
+				std::string description_;
+				int batchIndicator_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_ADDMONITORREQUEST_H_

vcs/include/alibabacloud/vcs/model/AddMonitorResult.h

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

vcs/include/alibabacloud/vcs/model/GetBodyOptionsRequest.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_VCS_MODEL_GETBODYOPTIONSREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT GetBodyOptionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetBodyOptionsRequest();
+				~GetBodyOptionsRequest();
+
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+
+            private:
+				std::string corpId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_GETBODYOPTIONSREQUEST_H_

vcs/include/alibabacloud/vcs/model/GetBodyOptionsResult.h

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

vcs/include/alibabacloud/vcs/model/GetDeviceLiveUrlRequest.h

@@ -39,13 +39,10 @@ namespace AlibabaCloud
 				void setCorpId(const std::string& corpId);
 				std::string getGbId()const;
 				void setGbId(const std::string& gbId);
-				long getDeviceId()const;
-				void setDeviceId(long deviceId);
 
             private:
 				std::string corpId_;
 				std::string gbId_;
-				long deviceId_;
 
 			};
 		}

vcs/include/alibabacloud/vcs/model/GetDeviceVideoUrlRequest.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_VCS_MODEL_GETDEVICEVIDEOURLREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_GETDEVICEVIDEOURLREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT GetDeviceVideoUrlRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDeviceVideoUrlRequest();
+				~GetDeviceVideoUrlRequest();
+
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+				std::string getGbId()const;
+				void setGbId(const std::string& gbId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+
+            private:
+				std::string corpId_;
+				std::string gbId_;
+				long endTime_;
+				long startTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_GETDEVICEVIDEOURLREQUEST_H_

vcs/include/alibabacloud/vcs/model/GetDeviceVideoUrlResult.h

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

vcs/include/alibabacloud/vcs/model/GetFaceOptionsRequest.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_VCS_MODEL_GETFACEOPTIONSREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT GetFaceOptionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetFaceOptionsRequest();
+				~GetFaceOptionsRequest();
+
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+
+            private:
+				std::string corpId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_GETFACEOPTIONSREQUEST_H_

vcs/include/alibabacloud/vcs/model/GetFaceOptionsResult.h

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

vcs/include/alibabacloud/vcs/model/GetMonitorResultRequest.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_VCS_MODEL_GETMONITORRESULTREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT GetMonitorResultRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetMonitorResultRequest();
+				~GetMonitorResultRequest();
+
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getMinRecordId()const;
+				void setMinRecordId(const std::string& minRecordId);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+
+            private:
+				std::string corpId_;
+				long endTime_;
+				long startTime_;
+				std::string minRecordId_;
+				std::string taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTREQUEST_H_

vcs/include/alibabacloud/vcs/model/GetMonitorResultResult.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_VCS_MODEL_GETMONITORRESULTRESULT_H_
+#define ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT GetMonitorResultResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string maxRecordId;
+				};
+				struct RecordsItem
+				{
+					std::string shotPicUrl;
+					std::string gbId;
+					std::string monitorPicUrl;
+					std::string shotTime;
+				};
+
+
+				GetMonitorResultResult();
+				explicit GetMonitorResultResult(const std::string &payload);
+				~GetMonitorResultResult();
+				std::string getScore()const;
+				std::string getMessage()const;
+				std::string getRightBottomX()const;
+				std::string getRightBottomY()const;
+				Data getData()const;
+				std::string getLeftTopY()const;
+				std::vector<RecordsItem> getRecords()const;
+				std::string getCode()const;
+				std::string getLeftTopX()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string score_;
+				std::string message_;
+				std::string rightBottomX_;
+				std::string rightBottomY_;
+				Data data_;
+				std::string leftTopY_;
+				std::vector<RecordsItem> records_;
+				std::string code_;
+				std::string leftTopX_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_GETMONITORRESULTRESULT_H_

vcs/include/alibabacloud/vcs/model/ListDevicesResult.h

@@ -49,7 +49,7 @@ namespace AlibabaCloud
 						std::string sipPassword;
 						std::string deviceType;
 						std::string deviceAddress;
-						std::string gBid;
+						std::string gbId;
 						std::string bitRate;
 						std::string deviceSite;
 						std::string sipServerPort;

vcs/include/alibabacloud/vcs/model/SearchBodyRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VCS_MODEL_SEARCHBODYREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_SEARCHBODYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT SearchBodyRequest : public RpcServiceRequest
+			{
+
+			public:
+				SearchBodyRequest();
+				~SearchBodyRequest();
+
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+				std::string getGbId()const;
+				void setGbId(const std::string& gbId);
+				long getStartTimeStamp()const;
+				void setStartTimeStamp(long startTimeStamp);
+				long getEndTimeStamp()const;
+				void setEndTimeStamp(long endTimeStamp);
+				int getPageNo()const;
+				void setPageNo(int pageNo);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getOptionList()const;
+				void setOptionList(const std::string& optionList);
+
+            private:
+				std::string corpId_;
+				std::string gbId_;
+				long startTimeStamp_;
+				long endTimeStamp_;
+				int pageNo_;
+				int pageSize_;
+				std::string optionList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_SEARCHBODYREQUEST_H_

vcs/include/alibabacloud/vcs/model/SearchBodyResult.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_VCS_MODEL_SEARCHBODYRESULT_H_
+#define ALIBABACLOUD_VCS_MODEL_SEARCHBODYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT SearchBodyResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Record
+					{
+						std::string targetImageUrl;
+						float score;
+						float rightBottomX;
+						float rightBottomY;
+						std::string gbId;
+						std::string imageUrl;
+						float leftTopY;
+						float leftTopX;
+					};
+					int totalCount;
+					int pageSize;
+					int totalPage;
+					int pageNo;
+					std::vector<Record> records;
+				};
+
+
+				SearchBodyResult();
+				explicit SearchBodyResult(const std::string &payload);
+				~SearchBodyResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_SEARCHBODYRESULT_H_

vcs/include/alibabacloud/vcs/model/StopMonitorRequest.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_VCS_MODEL_STOPMONITORREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_STOPMONITORREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT StopMonitorRequest : public RpcServiceRequest
+			{
+
+			public:
+				StopMonitorRequest();
+				~StopMonitorRequest();
+
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+
+            private:
+				std::string taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_STOPMONITORREQUEST_H_

vcs/include/alibabacloud/vcs/model/StopMonitorResult.h

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

vcs/include/alibabacloud/vcs/model/UpdateDeviceRequest.h

@@ -41,10 +41,10 @@ namespace AlibabaCloud
 				void setCorpId(const std::string& corpId);
 				std::string getGbId()const;
 				void setGbId(const std::string& gbId);
+				std::string getBitRate()const;
+				void setBitRate(const std::string& bitRate);
 				std::string getDeviceDirection()const;
 				void setDeviceDirection(const std::string& deviceDirection);
-				std::string getDeviceRate()const;
-				void setDeviceRate(const std::string& deviceRate);
 				std::string getDeviceAddress()const;
 				void setDeviceAddress(const std::string& deviceAddress);
 				std::string getDeviceType()const;
@@ -60,8 +60,8 @@ namespace AlibabaCloud
 				std::string deviceSite_;
 				std::string corpId_;
 				std::string gbId_;
+				std::string bitRate_;
 				std::string deviceDirection_;
-				std::string deviceRate_;
 				std::string deviceAddress_;
 				std::string deviceType_;
 				std::string deviceResolution_;

vcs/include/alibabacloud/vcs/model/UpdateMonitorRequest.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_VCS_MODEL_UPDATEMONITORREQUEST_H_
+#define ALIBABACLOUD_VCS_MODEL_UPDATEMONITORREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/vcs/VcsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Vcs
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_VCS_EXPORT UpdateMonitorRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateMonitorRequest();
+				~UpdateMonitorRequest();
+
+				std::string getDeviceOperateType()const;
+				void setDeviceOperateType(const std::string& deviceOperateType);
+				std::string getCorpId()const;
+				void setCorpId(const std::string& corpId);
+				std::string getPicList()const;
+				void setPicList(const std::string& picList);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getRuleName()const;
+				void setRuleName(const std::string& ruleName);
+				std::string getPicOperateType()const;
+				void setPicOperateType(const std::string& picOperateType);
+				std::string getAttributeName()const;
+				void setAttributeName(const std::string& attributeName);
+				std::string getAttributeValueList()const;
+				void setAttributeValueList(const std::string& attributeValueList);
+				std::string getDeviceList()const;
+				void setDeviceList(const std::string& deviceList);
+				std::string getAttributeOperateType()const;
+				void setAttributeOperateType(const std::string& attributeOperateType);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+
+            private:
+				std::string deviceOperateType_;
+				std::string corpId_;
+				std::string picList_;
+				std::string description_;
+				std::string ruleName_;
+				std::string picOperateType_;
+				std::string attributeName_;
+				std::string attributeValueList_;
+				std::string deviceList_;
+				std::string attributeOperateType_;
+				std::string taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_VCS_MODEL_UPDATEMONITORREQUEST_H_

vcs/include/alibabacloud/vcs/model/UpdateMonitorResult.h

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

vcs/src/VcsClient.cc

@@ -87,6 +87,42 @@ VcsClient::AddDeviceOutcomeCallable VcsClient::addDeviceCallable(const AddDevice
 	return task->get_future();
 }
 
+VcsClient::AddMonitorOutcome VcsClient::addMonitor(const AddMonitorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddMonitorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddMonitorOutcome(AddMonitorResult(outcome.result()));
+	else
+		return AddMonitorOutcome(outcome.error());
+}
+
+void VcsClient::addMonitorAsync(const AddMonitorRequest& request, const AddMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addMonitor(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::AddMonitorOutcomeCallable VcsClient::addMonitorCallable(const AddMonitorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddMonitorOutcome()>>(
+			[this, request]()
+			{
+			return this->addMonitor(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VcsClient::CreateCorpOutcome VcsClient::createCorp(const CreateCorpRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,42 @@ VcsClient::DeleteDeviceOutcomeCallable VcsClient::deleteDeviceCallable(const Del
 	return task->get_future();
 }
 
+VcsClient::GetBodyOptionsOutcome VcsClient::getBodyOptions(const GetBodyOptionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetBodyOptionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetBodyOptionsOutcome(GetBodyOptionsResult(outcome.result()));
+	else
+		return GetBodyOptionsOutcome(outcome.error());
+}
+
+void VcsClient::getBodyOptionsAsync(const GetBodyOptionsRequest& request, const GetBodyOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getBodyOptions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::GetBodyOptionsOutcomeCallable VcsClient::getBodyOptionsCallable(const GetBodyOptionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetBodyOptionsOutcome()>>(
+			[this, request]()
+			{
+			return this->getBodyOptions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VcsClient::GetDeviceLiveUrlOutcome VcsClient::getDeviceLiveUrl(const GetDeviceLiveUrlRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +267,78 @@ VcsClient::GetDeviceLiveUrlOutcomeCallable VcsClient::getDeviceLiveUrlCallable(c
 	return task->get_future();
 }
 
+VcsClient::GetDeviceVideoUrlOutcome VcsClient::getDeviceVideoUrl(const GetDeviceVideoUrlRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDeviceVideoUrlOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDeviceVideoUrlOutcome(GetDeviceVideoUrlResult(outcome.result()));
+	else
+		return GetDeviceVideoUrlOutcome(outcome.error());
+}
+
+void VcsClient::getDeviceVideoUrlAsync(const GetDeviceVideoUrlRequest& request, const GetDeviceVideoUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDeviceVideoUrl(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::GetDeviceVideoUrlOutcomeCallable VcsClient::getDeviceVideoUrlCallable(const GetDeviceVideoUrlRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDeviceVideoUrlOutcome()>>(
+			[this, request]()
+			{
+			return this->getDeviceVideoUrl(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+VcsClient::GetFaceOptionsOutcome VcsClient::getFaceOptions(const GetFaceOptionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetFaceOptionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetFaceOptionsOutcome(GetFaceOptionsResult(outcome.result()));
+	else
+		return GetFaceOptionsOutcome(outcome.error());
+}
+
+void VcsClient::getFaceOptionsAsync(const GetFaceOptionsRequest& request, const GetFaceOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getFaceOptions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::GetFaceOptionsOutcomeCallable VcsClient::getFaceOptionsCallable(const GetFaceOptionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetFaceOptionsOutcome()>>(
+			[this, request]()
+			{
+			return this->getFaceOptions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VcsClient::GetInventoryOutcome VcsClient::getInventory(const GetInventoryRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +375,42 @@ VcsClient::GetInventoryOutcomeCallable VcsClient::getInventoryCallable(const Get
 	return task->get_future();
 }
 
+VcsClient::GetMonitorResultOutcome VcsClient::getMonitorResult(const GetMonitorResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetMonitorResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetMonitorResultOutcome(GetMonitorResultResult(outcome.result()));
+	else
+		return GetMonitorResultOutcome(outcome.error());
+}
+
+void VcsClient::getMonitorResultAsync(const GetMonitorResultRequest& request, const GetMonitorResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getMonitorResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::GetMonitorResultOutcomeCallable VcsClient::getMonitorResultCallable(const GetMonitorResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetMonitorResultOutcome()>>(
+			[this, request]()
+			{
+			return this->getMonitorResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VcsClient::ListCorpsOutcome VcsClient::listCorps(const ListCorpsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +519,42 @@ VcsClient::RecognizeImageOutcomeCallable VcsClient::recognizeImageCallable(const
 	return task->get_future();
 }
 
+VcsClient::SearchBodyOutcome VcsClient::searchBody(const SearchBodyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchBodyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchBodyOutcome(SearchBodyResult(outcome.result()));
+	else
+		return SearchBodyOutcome(outcome.error());
+}
+
+void VcsClient::searchBodyAsync(const SearchBodyRequest& request, const SearchBodyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchBody(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::SearchBodyOutcomeCallable VcsClient::searchBodyCallable(const SearchBodyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchBodyOutcome()>>(
+			[this, request]()
+			{
+			return this->searchBody(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VcsClient::SearchFaceOutcome VcsClient::searchFace(const SearchFaceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +591,42 @@ VcsClient::SearchFaceOutcomeCallable VcsClient::searchFaceCallable(const SearchF
 	return task->get_future();
 }
 
+VcsClient::StopMonitorOutcome VcsClient::stopMonitor(const StopMonitorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopMonitorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopMonitorOutcome(StopMonitorResult(outcome.result()));
+	else
+		return StopMonitorOutcome(outcome.error());
+}
+
+void VcsClient::stopMonitorAsync(const StopMonitorRequest& request, const StopMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopMonitor(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::StopMonitorOutcomeCallable VcsClient::stopMonitorCallable(const StopMonitorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopMonitorOutcome()>>(
+			[this, request]()
+			{
+			return this->stopMonitor(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VcsClient::UpdateCorpOutcome VcsClient::updateCorp(const UpdateCorpRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,3 +699,39 @@ VcsClient::UpdateDeviceOutcomeCallable VcsClient::updateDeviceCallable(const Upd
 	return task->get_future();
 }
 
+VcsClient::UpdateMonitorOutcome VcsClient::updateMonitor(const UpdateMonitorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateMonitorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateMonitorOutcome(UpdateMonitorResult(outcome.result()));
+	else
+		return UpdateMonitorOutcome(outcome.error());
+}
+
+void VcsClient::updateMonitorAsync(const UpdateMonitorRequest& request, const UpdateMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateMonitor(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VcsClient::UpdateMonitorOutcomeCallable VcsClient::updateMonitorCallable(const UpdateMonitorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateMonitorOutcome()>>(
+			[this, request]()
+			{
+			return this->updateMonitor(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

vcs/src/model/AddDeviceRequest.cc

@@ -60,26 +60,26 @@ void AddDeviceRequest::setGbId(const std::string& gbId)
 	setBodyParameter("GbId", gbId);
 }
 
-std::string AddDeviceRequest::getDeviceDirection()const
+std::string AddDeviceRequest::getBitRate()const
 {
-	return deviceDirection_;
+	return bitRate_;
 }
 
-void AddDeviceRequest::setDeviceDirection(const std::string& deviceDirection)
+void AddDeviceRequest::setBitRate(const std::string& bitRate)
 {
-	deviceDirection_ = deviceDirection;
-	setBodyParameter("DeviceDirection", deviceDirection);
+	bitRate_ = bitRate;
+	setBodyParameter("BitRate", bitRate);
 }
 
-std::string AddDeviceRequest::getDeviceRate()const
+std::string AddDeviceRequest::getDeviceDirection()const
 {
-	return deviceRate_;
+	return deviceDirection_;
 }
 
-void AddDeviceRequest::setDeviceRate(const std::string& deviceRate)
+void AddDeviceRequest::setDeviceDirection(const std::string& deviceDirection)
 {
-	deviceRate_ = deviceRate;
-	setBodyParameter("DeviceRate", deviceRate);
+	deviceDirection_ = deviceDirection;
+	setBodyParameter("DeviceDirection", deviceDirection);
 }
 
 std::string AddDeviceRequest::getDeviceAddress()const

vcs/src/model/AddMonitorRequest.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/vcs/model/AddMonitorRequest.h>
+
+using AlibabaCloud::Vcs::Model::AddMonitorRequest;
+
+AddMonitorRequest::AddMonitorRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "AddMonitor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddMonitorRequest::~AddMonitorRequest()
+{}
+
+std::string AddMonitorRequest::getMonitorType()const
+{
+	return monitorType_;
+}
+
+void AddMonitorRequest::setMonitorType(const std::string& monitorType)
+{
+	monitorType_ = monitorType;
+	setBodyParameter("MonitorType", monitorType);
+}
+
+std::string AddMonitorRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void AddMonitorRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+
+std::string AddMonitorRequest::getDescription()const
+{
+	return description_;
+}
+
+void AddMonitorRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+int AddMonitorRequest::getBatchIndicator()const
+{
+	return batchIndicator_;
+}
+
+void AddMonitorRequest::setBatchIndicator(int batchIndicator)
+{
+	batchIndicator_ = batchIndicator;
+	setBodyParameter("BatchIndicator", std::to_string(batchIndicator));
+}
+

vcs/src/model/AddMonitorResult.cc

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

vcs/src/model/GetBodyOptionsRequest.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/vcs/model/GetBodyOptionsRequest.h>
+
+using AlibabaCloud::Vcs::Model::GetBodyOptionsRequest;
+
+GetBodyOptionsRequest::GetBodyOptionsRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "GetBodyOptions")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetBodyOptionsRequest::~GetBodyOptionsRequest()
+{}
+
+std::string GetBodyOptionsRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void GetBodyOptionsRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+

vcs/src/model/GetBodyOptionsResult.cc

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/vcs/model/GetBodyOptionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vcs;
+using namespace AlibabaCloud::Vcs::Model;
+
+GetBodyOptionsResult::GetBodyOptionsResult() :
+	ServiceResult()
+{}
+
+GetBodyOptionsResult::GetBodyOptionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetBodyOptionsResult::~GetBodyOptionsResult()
+{}
+
+void GetBodyOptionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["Key"].isNull())
+			dataObject.key = valueDataDataItem["Key"].asString();
+		if(!valueDataDataItem["Name"].isNull())
+			dataObject.name = valueDataDataItem["Name"].asString();
+		auto allOptionListNode = allDataNode["OptionList"]["OptionListItem"];
+		for (auto allDataNodeOptionListOptionListItem : allOptionListNode)
+		{
+			DataItem::OptionListItem optionListObject;
+			if(!allDataNodeOptionListOptionListItem["Key"].isNull())
+				optionListObject.key = allDataNodeOptionListOptionListItem["Key"].asString();
+			if(!allDataNodeOptionListOptionListItem["Name"].isNull())
+				optionListObject.name = allDataNodeOptionListOptionListItem["Name"].asString();
+			dataObject.optionList.push_back(optionListObject);
+		}
+		data_.push_back(dataObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetBodyOptionsResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetBodyOptionsResult::DataItem> GetBodyOptionsResult::getData()const
+{
+	return data_;
+}
+
+std::string GetBodyOptionsResult::getCode()const
+{
+	return code_;
+}
+

vcs/src/model/GetDeviceLiveUrlRequest.cc

@@ -49,14 +49,3 @@ void GetDeviceLiveUrlRequest::setGbId(const std::string& gbId)
 	setBodyParameter("GbId", gbId);
 }
 
-long GetDeviceLiveUrlRequest::getDeviceId()const
-{
-	return deviceId_;
-}
-
-void GetDeviceLiveUrlRequest::setDeviceId(long deviceId)
-{
-	deviceId_ = deviceId;
-	setBodyParameter("DeviceId", std::to_string(deviceId));
-}
-

vcs/src/model/GetDeviceVideoUrlRequest.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/vcs/model/GetDeviceVideoUrlRequest.h>
+
+using AlibabaCloud::Vcs::Model::GetDeviceVideoUrlRequest;
+
+GetDeviceVideoUrlRequest::GetDeviceVideoUrlRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "GetDeviceVideoUrl")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetDeviceVideoUrlRequest::~GetDeviceVideoUrlRequest()
+{}
+
+std::string GetDeviceVideoUrlRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void GetDeviceVideoUrlRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+
+std::string GetDeviceVideoUrlRequest::getGbId()const
+{
+	return gbId_;
+}
+
+void GetDeviceVideoUrlRequest::setGbId(const std::string& gbId)
+{
+	gbId_ = gbId;
+	setBodyParameter("GbId", gbId);
+}
+
+long GetDeviceVideoUrlRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetDeviceVideoUrlRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setBodyParameter("EndTime", std::to_string(endTime));
+}
+
+long GetDeviceVideoUrlRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetDeviceVideoUrlRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setBodyParameter("StartTime", std::to_string(startTime));
+}
+

vcs/src/model/GetDeviceVideoUrlResult.cc

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

vcs/src/model/GetFaceOptionsRequest.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/vcs/model/GetFaceOptionsRequest.h>
+
+using AlibabaCloud::Vcs::Model::GetFaceOptionsRequest;
+
+GetFaceOptionsRequest::GetFaceOptionsRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "GetFaceOptions")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetFaceOptionsRequest::~GetFaceOptionsRequest()
+{}
+
+std::string GetFaceOptionsRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void GetFaceOptionsRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+

vcs/src/model/GetFaceOptionsResult.cc

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/vcs/model/GetFaceOptionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vcs;
+using namespace AlibabaCloud::Vcs::Model;
+
+GetFaceOptionsResult::GetFaceOptionsResult() :
+	ServiceResult()
+{}
+
+GetFaceOptionsResult::GetFaceOptionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetFaceOptionsResult::~GetFaceOptionsResult()
+{}
+
+void GetFaceOptionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["Key"].isNull())
+			dataObject.key = valueDataDataItem["Key"].asString();
+		if(!valueDataDataItem["Name"].isNull())
+			dataObject.name = valueDataDataItem["Name"].asString();
+		auto allOptionListNode = allDataNode["OptionList"]["OptionListItem"];
+		for (auto allDataNodeOptionListOptionListItem : allOptionListNode)
+		{
+			DataItem::OptionListItem optionListObject;
+			if(!allDataNodeOptionListOptionListItem["Key"].isNull())
+				optionListObject.key = allDataNodeOptionListOptionListItem["Key"].asString();
+			if(!allDataNodeOptionListOptionListItem["Name"].isNull())
+				optionListObject.name = allDataNodeOptionListOptionListItem["Name"].asString();
+			dataObject.optionList.push_back(optionListObject);
+		}
+		data_.push_back(dataObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetFaceOptionsResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetFaceOptionsResult::DataItem> GetFaceOptionsResult::getData()const
+{
+	return data_;
+}
+
+std::string GetFaceOptionsResult::getCode()const
+{
+	return code_;
+}
+

vcs/src/model/GetMonitorResultRequest.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/vcs/model/GetMonitorResultRequest.h>
+
+using AlibabaCloud::Vcs::Model::GetMonitorResultRequest;
+
+GetMonitorResultRequest::GetMonitorResultRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "GetMonitorResult")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetMonitorResultRequest::~GetMonitorResultRequest()
+{}
+
+std::string GetMonitorResultRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void GetMonitorResultRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+
+long GetMonitorResultRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetMonitorResultRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setBodyParameter("EndTime", std::to_string(endTime));
+}
+
+long GetMonitorResultRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetMonitorResultRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setBodyParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetMonitorResultRequest::getMinRecordId()const
+{
+	return minRecordId_;
+}
+
+void GetMonitorResultRequest::setMinRecordId(const std::string& minRecordId)
+{
+	minRecordId_ = minRecordId;
+	setBodyParameter("MinRecordId", minRecordId);
+}
+
+std::string GetMonitorResultRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void GetMonitorResultRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setBodyParameter("TaskId", taskId);
+}
+

vcs/src/model/GetMonitorResultResult.cc

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/vcs/model/GetMonitorResultResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vcs;
+using namespace AlibabaCloud::Vcs::Model;
+
+GetMonitorResultResult::GetMonitorResultResult() :
+	ServiceResult()
+{}
+
+GetMonitorResultResult::GetMonitorResultResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetMonitorResultResult::~GetMonitorResultResult()
+{}
+
+void GetMonitorResultResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRecordsNode = value["Records"]["RecordsItem"];
+	for (auto valueRecordsRecordsItem : allRecordsNode)
+	{
+		RecordsItem recordsObject;
+		if(!valueRecordsRecordsItem["GbId"].isNull())
+			recordsObject.gbId = valueRecordsRecordsItem["GbId"].asString();
+		if(!valueRecordsRecordsItem["ShotTime"].isNull())
+			recordsObject.shotTime = valueRecordsRecordsItem["ShotTime"].asString();
+		if(!valueRecordsRecordsItem["MonitorPicUrl"].isNull())
+			recordsObject.monitorPicUrl = valueRecordsRecordsItem["MonitorPicUrl"].asString();
+		if(!valueRecordsRecordsItem["ShotPicUrl"].isNull())
+			recordsObject.shotPicUrl = valueRecordsRecordsItem["ShotPicUrl"].asString();
+		records_.push_back(recordsObject);
+	}
+	auto dataNode = value["Data"];
+	if(!dataNode["MaxRecordId"].isNull())
+		data_.maxRecordId = dataNode["MaxRecordId"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Score"].isNull())
+		score_ = value["Score"].asString();
+	if(!value["LeftTopX"].isNull())
+		leftTopX_ = value["LeftTopX"].asString();
+	if(!value["LeftTopY"].isNull())
+		leftTopY_ = value["LeftTopY"].asString();
+	if(!value["RightBottomX"].isNull())
+		rightBottomX_ = value["RightBottomX"].asString();
+	if(!value["RightBottomY"].isNull())
+		rightBottomY_ = value["RightBottomY"].asString();
+
+}
+
+std::string GetMonitorResultResult::getScore()const
+{
+	return score_;
+}
+
+std::string GetMonitorResultResult::getMessage()const
+{
+	return message_;
+}
+
+std::string GetMonitorResultResult::getRightBottomX()const
+{
+	return rightBottomX_;
+}
+
+std::string GetMonitorResultResult::getRightBottomY()const
+{
+	return rightBottomY_;
+}
+
+GetMonitorResultResult::Data GetMonitorResultResult::getData()const
+{
+	return data_;
+}
+
+std::string GetMonitorResultResult::getLeftTopY()const
+{
+	return leftTopY_;
+}
+
+std::vector<GetMonitorResultResult::RecordsItem> GetMonitorResultResult::getRecords()const
+{
+	return records_;
+}
+
+std::string GetMonitorResultResult::getCode()const
+{
+	return code_;
+}
+
+std::string GetMonitorResultResult::getLeftTopX()const
+{
+	return leftTopX_;
+}
+

vcs/src/model/ListDevicesResult.cc

@@ -58,8 +58,8 @@ void ListDevicesResult::parse(const std::string &payload)
 			recordObject.bitRate = dataNodeRecordsRecord["BitRate"].asString();
 		if(!dataNodeRecordsRecord["CoverImageUrl"].isNull())
 			recordObject.coverImageUrl = dataNodeRecordsRecord["CoverImageUrl"].asString();
-		if(!dataNodeRecordsRecord["GBid"].isNull())
-			recordObject.gBid = dataNodeRecordsRecord["GBid"].asString();
+		if(!dataNodeRecordsRecord["GbId"].isNull())
+			recordObject.gbId = dataNodeRecordsRecord["GbId"].asString();
 		if(!dataNodeRecordsRecord["DeviceAddress"].isNull())
 			recordObject.deviceAddress = dataNodeRecordsRecord["DeviceAddress"].asString();
 		if(!dataNodeRecordsRecord["DeviceDirection"].isNull())

vcs/src/model/SearchBodyRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/vcs/model/SearchBodyRequest.h>
+
+using AlibabaCloud::Vcs::Model::SearchBodyRequest;
+
+SearchBodyRequest::SearchBodyRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "SearchBody")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SearchBodyRequest::~SearchBodyRequest()
+{}
+
+std::string SearchBodyRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void SearchBodyRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+
+std::string SearchBodyRequest::getGbId()const
+{
+	return gbId_;
+}
+
+void SearchBodyRequest::setGbId(const std::string& gbId)
+{
+	gbId_ = gbId;
+	setBodyParameter("GbId", gbId);
+}
+
+long SearchBodyRequest::getStartTimeStamp()const
+{
+	return startTimeStamp_;
+}
+
+void SearchBodyRequest::setStartTimeStamp(long startTimeStamp)
+{
+	startTimeStamp_ = startTimeStamp;
+	setBodyParameter("StartTimeStamp", std::to_string(startTimeStamp));
+}
+
+long SearchBodyRequest::getEndTimeStamp()const
+{
+	return endTimeStamp_;
+}
+
+void SearchBodyRequest::setEndTimeStamp(long endTimeStamp)
+{
+	endTimeStamp_ = endTimeStamp;
+	setBodyParameter("EndTimeStamp", std::to_string(endTimeStamp));
+}
+
+int SearchBodyRequest::getPageNo()const
+{
+	return pageNo_;
+}
+
+void SearchBodyRequest::setPageNo(int pageNo)
+{
+	pageNo_ = pageNo;
+	setBodyParameter("PageNo", std::to_string(pageNo));
+}
+
+int SearchBodyRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void SearchBodyRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setBodyParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string SearchBodyRequest::getOptionList()const
+{
+	return optionList_;
+}
+
+void SearchBodyRequest::setOptionList(const std::string& optionList)
+{
+	optionList_ = optionList;
+	setBodyParameter("OptionList", optionList);
+}
+

vcs/src/model/SearchBodyResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/vcs/model/SearchBodyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vcs;
+using namespace AlibabaCloud::Vcs::Model;
+
+SearchBodyResult::SearchBodyResult() :
+	ServiceResult()
+{}
+
+SearchBodyResult::SearchBodyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SearchBodyResult::~SearchBodyResult()
+{}
+
+void SearchBodyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["PageNo"].isNull())
+		data_.pageNo = std::stoi(dataNode["PageNo"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
+	if(!dataNode["TotalPage"].isNull())
+		data_.totalPage = std::stoi(dataNode["TotalPage"].asString());
+	auto allRecordsNode = dataNode["Records"]["Record"];
+	for (auto dataNodeRecordsRecord : allRecordsNode)
+	{
+		Data::Record recordObject;
+		if(!dataNodeRecordsRecord["GbId"].isNull())
+			recordObject.gbId = dataNodeRecordsRecord["GbId"].asString();
+		if(!dataNodeRecordsRecord["ImageUrl"].isNull())
+			recordObject.imageUrl = dataNodeRecordsRecord["ImageUrl"].asString();
+		if(!dataNodeRecordsRecord["LeftTopX"].isNull())
+			recordObject.leftTopX = std::stof(dataNodeRecordsRecord["LeftTopX"].asString());
+		if(!dataNodeRecordsRecord["LeftTopY"].isNull())
+			recordObject.leftTopY = std::stof(dataNodeRecordsRecord["LeftTopY"].asString());
+		if(!dataNodeRecordsRecord["RightBottomX"].isNull())
+			recordObject.rightBottomX = std::stof(dataNodeRecordsRecord["RightBottomX"].asString());
+		if(!dataNodeRecordsRecord["RightBottomY"].isNull())
+			recordObject.rightBottomY = std::stof(dataNodeRecordsRecord["RightBottomY"].asString());
+		if(!dataNodeRecordsRecord["Score"].isNull())
+			recordObject.score = std::stof(dataNodeRecordsRecord["Score"].asString());
+		if(!dataNodeRecordsRecord["TargetImageUrl"].isNull())
+			recordObject.targetImageUrl = dataNodeRecordsRecord["TargetImageUrl"].asString();
+		data_.records.push_back(recordObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string SearchBodyResult::getMessage()const
+{
+	return message_;
+}
+
+SearchBodyResult::Data SearchBodyResult::getData()const
+{
+	return data_;
+}
+
+std::string SearchBodyResult::getCode()const
+{
+	return code_;
+}
+

vcs/src/model/StopMonitorRequest.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/vcs/model/StopMonitorRequest.h>
+
+using AlibabaCloud::Vcs::Model::StopMonitorRequest;
+
+StopMonitorRequest::StopMonitorRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "StopMonitor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StopMonitorRequest::~StopMonitorRequest()
+{}
+
+std::string StopMonitorRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void StopMonitorRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setBodyParameter("TaskId", taskId);
+}
+

vcs/src/model/StopMonitorResult.cc

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

vcs/src/model/UpdateDeviceRequest.cc

@@ -60,26 +60,26 @@ void UpdateDeviceRequest::setGbId(const std::string& gbId)
 	setBodyParameter("GbId", gbId);
 }
 
-std::string UpdateDeviceRequest::getDeviceDirection()const
+std::string UpdateDeviceRequest::getBitRate()const
 {
-	return deviceDirection_;
+	return bitRate_;
 }
 
-void UpdateDeviceRequest::setDeviceDirection(const std::string& deviceDirection)
+void UpdateDeviceRequest::setBitRate(const std::string& bitRate)
 {
-	deviceDirection_ = deviceDirection;
-	setBodyParameter("DeviceDirection", deviceDirection);
+	bitRate_ = bitRate;
+	setBodyParameter("BitRate", bitRate);
 }
 
-std::string UpdateDeviceRequest::getDeviceRate()const
+std::string UpdateDeviceRequest::getDeviceDirection()const
 {
-	return deviceRate_;
+	return deviceDirection_;
 }
 
-void UpdateDeviceRequest::setDeviceRate(const std::string& deviceRate)
+void UpdateDeviceRequest::setDeviceDirection(const std::string& deviceDirection)
 {
-	deviceRate_ = deviceRate;
-	setBodyParameter("DeviceRate", deviceRate);
+	deviceDirection_ = deviceDirection;
+	setBodyParameter("DeviceDirection", deviceDirection);
 }
 
 std::string UpdateDeviceRequest::getDeviceAddress()const

vcs/src/model/UpdateMonitorRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/vcs/model/UpdateMonitorRequest.h>
+
+using AlibabaCloud::Vcs::Model::UpdateMonitorRequest;
+
+UpdateMonitorRequest::UpdateMonitorRequest() :
+	RpcServiceRequest("vcs", "2020-05-15", "UpdateMonitor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateMonitorRequest::~UpdateMonitorRequest()
+{}
+
+std::string UpdateMonitorRequest::getDeviceOperateType()const
+{
+	return deviceOperateType_;
+}
+
+void UpdateMonitorRequest::setDeviceOperateType(const std::string& deviceOperateType)
+{
+	deviceOperateType_ = deviceOperateType;
+	setBodyParameter("DeviceOperateType", deviceOperateType);
+}
+
+std::string UpdateMonitorRequest::getCorpId()const
+{
+	return corpId_;
+}
+
+void UpdateMonitorRequest::setCorpId(const std::string& corpId)
+{
+	corpId_ = corpId;
+	setBodyParameter("CorpId", corpId);
+}
+
+std::string UpdateMonitorRequest::getPicList()const
+{
+	return picList_;
+}
+
+void UpdateMonitorRequest::setPicList(const std::string& picList)
+{
+	picList_ = picList;
+	setBodyParameter("PicList", picList);
+}
+
+std::string UpdateMonitorRequest::getDescription()const
+{
+	return description_;
+}
+
+void UpdateMonitorRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+std::string UpdateMonitorRequest::getRuleName()const
+{
+	return ruleName_;
+}
+
+void UpdateMonitorRequest::setRuleName(const std::string& ruleName)
+{
+	ruleName_ = ruleName;
+	setBodyParameter("RuleName", ruleName);
+}
+
+std::string UpdateMonitorRequest::getPicOperateType()const
+{
+	return picOperateType_;
+}
+
+void UpdateMonitorRequest::setPicOperateType(const std::string& picOperateType)
+{
+	picOperateType_ = picOperateType;
+	setBodyParameter("PicOperateType", picOperateType);
+}
+
+std::string UpdateMonitorRequest::getAttributeName()const
+{
+	return attributeName_;
+}
+
+void UpdateMonitorRequest::setAttributeName(const std::string& attributeName)
+{
+	attributeName_ = attributeName;
+	setBodyParameter("AttributeName", attributeName);
+}
+
+std::string UpdateMonitorRequest::getAttributeValueList()const
+{
+	return attributeValueList_;
+}
+
+void UpdateMonitorRequest::setAttributeValueList(const std::string& attributeValueList)
+{
+	attributeValueList_ = attributeValueList;
+	setBodyParameter("AttributeValueList", attributeValueList);
+}
+
+std::string UpdateMonitorRequest::getDeviceList()const
+{
+	return deviceList_;
+}
+
+void UpdateMonitorRequest::setDeviceList(const std::string& deviceList)
+{
+	deviceList_ = deviceList;
+	setBodyParameter("DeviceList", deviceList);
+}
+
+std::string UpdateMonitorRequest::getAttributeOperateType()const
+{
+	return attributeOperateType_;
+}
+
+void UpdateMonitorRequest::setAttributeOperateType(const std::string& attributeOperateType)
+{
+	attributeOperateType_ = attributeOperateType;
+	setBodyParameter("AttributeOperateType", attributeOperateType);
+}
+
+std::string UpdateMonitorRequest::getTaskId()const
+{
+	return taskId_;
+}
+
+void UpdateMonitorRequest::setTaskId(const std::string& taskId)
+{
+	taskId_ = taskId;
+	setBodyParameter("TaskId", taskId);
+}
+

vcs/src/model/UpdateMonitorResult.cc

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