SMARTAG SDK Auto Released By jijun.jj,Version：1.21.6

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,7 @@
+2018-08-13 Version: 1.21.6
+1, Add cross domain support.
+2, Add parameter SerialNumber to interface RebootSmartAccessGateway.
+
 2018-08-08 Version: 1.21.5
 1, The official release 4.0.0
 

CMakeLists.txt

@@ -85,4 +85,5 @@ add_subdirectory(mopen)
 add_subdirectory(mts)
 add_subdirectory(iot)
 add_subdirectory(linkface)
-add_subdirectory(ots)
+add_subdirectory(ots)
+add_subdirectory(smartag)

VERSION

@@ -1 +1 @@
-1.21.5
+1.21.6

smartag/CMakeLists.txt

@@ -0,0 +1,166 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(smartag_public_header 
+	include/alibabacloud/smartag/SmartagClient.h
+	include/alibabacloud/smartag/SmartagExport.h )
+
+set(smartag_public_header_model 
+	include/alibabacloud/smartag/model/DescribeSmartAccessGatewaysRequest.h
+	include/alibabacloud/smartag/model/DescribeSmartAccessGatewaysResult.h
+	include/alibabacloud/smartag/model/SwitchCloudBoxHaStateRequest.h
+	include/alibabacloud/smartag/model/SwitchCloudBoxHaStateResult.h
+	include/alibabacloud/smartag/model/UnbindSmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/UnbindSmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/CreateSmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/CreateSmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/DeleteDedicatedLineBackupRequest.h
+	include/alibabacloud/smartag/model/DeleteDedicatedLineBackupResult.h
+	include/alibabacloud/smartag/model/UnlockSmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/UnlockSmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/ActivateSmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/ActivateSmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/CreateDedicatedLineBackupRequest.h
+	include/alibabacloud/smartag/model/CreateDedicatedLineBackupResult.h
+	include/alibabacloud/smartag/model/DescribeSmartAccessGatewayHaRequest.h
+	include/alibabacloud/smartag/model/DescribeSmartAccessGatewayHaResult.h
+	include/alibabacloud/smartag/model/ModifyCloudConnectNetworkRequest.h
+	include/alibabacloud/smartag/model/ModifyCloudConnectNetworkResult.h
+	include/alibabacloud/smartag/model/DeleteCloudConnectNetworkRequest.h
+	include/alibabacloud/smartag/model/DeleteCloudConnectNetworkResult.h
+	include/alibabacloud/smartag/model/CreateCloudConnectNetworkRequest.h
+	include/alibabacloud/smartag/model/CreateCloudConnectNetworkResult.h
+	include/alibabacloud/smartag/model/RebootSmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/RebootSmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/BindSmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/BindSmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/DescribeRegionsRequest.h
+	include/alibabacloud/smartag/model/DescribeRegionsResult.h
+	include/alibabacloud/smartag/model/GetSmartAccessGatewayUseLimitRequest.h
+	include/alibabacloud/smartag/model/GetSmartAccessGatewayUseLimitResult.h
+	include/alibabacloud/smartag/model/ModifySmartAccessGatewayRequest.h
+	include/alibabacloud/smartag/model/ModifySmartAccessGatewayResult.h
+	include/alibabacloud/smartag/model/DescribeCloudConnectNetworksRequest.h
+	include/alibabacloud/smartag/model/DescribeCloudConnectNetworksResult.h
+	include/alibabacloud/smartag/model/DescribeSmartAccessGatewayVersionsRequest.h
+	include/alibabacloud/smartag/model/DescribeSmartAccessGatewayVersionsResult.h
+	include/alibabacloud/smartag/model/UpdateSmartAccessGatewayVersionRequest.h
+	include/alibabacloud/smartag/model/UpdateSmartAccessGatewayVersionResult.h
+	include/alibabacloud/smartag/model/GetCloudConnectNetworkUseLimitRequest.h
+	include/alibabacloud/smartag/model/GetCloudConnectNetworkUseLimitResult.h )
+
+set(smartag_src 
+	src/SmartagClient.cc
+	src/model/DescribeSmartAccessGatewaysRequest.cc
+	src/model/DescribeSmartAccessGatewaysResult.cc
+	src/model/SwitchCloudBoxHaStateRequest.cc
+	src/model/SwitchCloudBoxHaStateResult.cc
+	src/model/UnbindSmartAccessGatewayRequest.cc
+	src/model/UnbindSmartAccessGatewayResult.cc
+	src/model/CreateSmartAccessGatewayRequest.cc
+	src/model/CreateSmartAccessGatewayResult.cc
+	src/model/DeleteDedicatedLineBackupRequest.cc
+	src/model/DeleteDedicatedLineBackupResult.cc
+	src/model/UnlockSmartAccessGatewayRequest.cc
+	src/model/UnlockSmartAccessGatewayResult.cc
+	src/model/ActivateSmartAccessGatewayRequest.cc
+	src/model/ActivateSmartAccessGatewayResult.cc
+	src/model/CreateDedicatedLineBackupRequest.cc
+	src/model/CreateDedicatedLineBackupResult.cc
+	src/model/DescribeSmartAccessGatewayHaRequest.cc
+	src/model/DescribeSmartAccessGatewayHaResult.cc
+	src/model/ModifyCloudConnectNetworkRequest.cc
+	src/model/ModifyCloudConnectNetworkResult.cc
+	src/model/DeleteCloudConnectNetworkRequest.cc
+	src/model/DeleteCloudConnectNetworkResult.cc
+	src/model/CreateCloudConnectNetworkRequest.cc
+	src/model/CreateCloudConnectNetworkResult.cc
+	src/model/RebootSmartAccessGatewayRequest.cc
+	src/model/RebootSmartAccessGatewayResult.cc
+	src/model/BindSmartAccessGatewayRequest.cc
+	src/model/BindSmartAccessGatewayResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/GetSmartAccessGatewayUseLimitRequest.cc
+	src/model/GetSmartAccessGatewayUseLimitResult.cc
+	src/model/ModifySmartAccessGatewayRequest.cc
+	src/model/ModifySmartAccessGatewayResult.cc
+	src/model/DescribeCloudConnectNetworksRequest.cc
+	src/model/DescribeCloudConnectNetworksResult.cc
+	src/model/DescribeSmartAccessGatewayVersionsRequest.cc
+	src/model/DescribeSmartAccessGatewayVersionsResult.cc
+	src/model/UpdateSmartAccessGatewayVersionRequest.cc
+	src/model/UpdateSmartAccessGatewayVersionResult.cc
+	src/model/GetCloudConnectNetworkUseLimitRequest.cc
+	src/model/GetCloudConnectNetworkUseLimitResult.cc )
+
+add_library(smartag ${LIB_TYPE}
+	${smartag_public_header}
+	${smartag_public_header_model}
+	${smartag_src})
+
+set_target_properties(smartag
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}smartag
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(smartag
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_SMARTAG_LIBRARY)
+endif()
+
+target_include_directories(smartag
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(smartag
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(smartag
+		jsoncpp)
+	target_include_directories(smartag
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(smartag
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(smartag
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(smartag
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(smartag
+		jsoncpp)
+endif()
+
+install(FILES ${smartag_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/smartag)
+install(FILES ${smartag_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/smartag/model)
+install(TARGETS smartag
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

smartag/include/alibabacloud/smartag/SmartagClient.h

@@ -0,0 +1,214 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SMARTAG_SMARTAGCLIENT_H_
+#define ALIBABACLOUD_SMARTAG_SMARTAGCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "SmartagExport.h"
+#include "model/DescribeSmartAccessGatewaysRequest.h"
+#include "model/DescribeSmartAccessGatewaysResult.h"
+#include "model/SwitchCloudBoxHaStateRequest.h"
+#include "model/SwitchCloudBoxHaStateResult.h"
+#include "model/UnbindSmartAccessGatewayRequest.h"
+#include "model/UnbindSmartAccessGatewayResult.h"
+#include "model/CreateSmartAccessGatewayRequest.h"
+#include "model/CreateSmartAccessGatewayResult.h"
+#include "model/DeleteDedicatedLineBackupRequest.h"
+#include "model/DeleteDedicatedLineBackupResult.h"
+#include "model/UnlockSmartAccessGatewayRequest.h"
+#include "model/UnlockSmartAccessGatewayResult.h"
+#include "model/ActivateSmartAccessGatewayRequest.h"
+#include "model/ActivateSmartAccessGatewayResult.h"
+#include "model/CreateDedicatedLineBackupRequest.h"
+#include "model/CreateDedicatedLineBackupResult.h"
+#include "model/DescribeSmartAccessGatewayHaRequest.h"
+#include "model/DescribeSmartAccessGatewayHaResult.h"
+#include "model/ModifyCloudConnectNetworkRequest.h"
+#include "model/ModifyCloudConnectNetworkResult.h"
+#include "model/DeleteCloudConnectNetworkRequest.h"
+#include "model/DeleteCloudConnectNetworkResult.h"
+#include "model/CreateCloudConnectNetworkRequest.h"
+#include "model/CreateCloudConnectNetworkResult.h"
+#include "model/RebootSmartAccessGatewayRequest.h"
+#include "model/RebootSmartAccessGatewayResult.h"
+#include "model/BindSmartAccessGatewayRequest.h"
+#include "model/BindSmartAccessGatewayResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/GetSmartAccessGatewayUseLimitRequest.h"
+#include "model/GetSmartAccessGatewayUseLimitResult.h"
+#include "model/ModifySmartAccessGatewayRequest.h"
+#include "model/ModifySmartAccessGatewayResult.h"
+#include "model/DescribeCloudConnectNetworksRequest.h"
+#include "model/DescribeCloudConnectNetworksResult.h"
+#include "model/DescribeSmartAccessGatewayVersionsRequest.h"
+#include "model/DescribeSmartAccessGatewayVersionsResult.h"
+#include "model/UpdateSmartAccessGatewayVersionRequest.h"
+#include "model/UpdateSmartAccessGatewayVersionResult.h"
+#include "model/GetCloudConnectNetworkUseLimitRequest.h"
+#include "model/GetCloudConnectNetworkUseLimitResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		class ALIBABACLOUD_SMARTAG_EXPORT SmartagClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::DescribeSmartAccessGatewaysResult> DescribeSmartAccessGatewaysOutcome;
+			typedef std::future<DescribeSmartAccessGatewaysOutcome> DescribeSmartAccessGatewaysOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DescribeSmartAccessGatewaysRequest&, const DescribeSmartAccessGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSmartAccessGatewaysAsyncHandler;
+			typedef Outcome<Error, Model::SwitchCloudBoxHaStateResult> SwitchCloudBoxHaStateOutcome;
+			typedef std::future<SwitchCloudBoxHaStateOutcome> SwitchCloudBoxHaStateOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::SwitchCloudBoxHaStateRequest&, const SwitchCloudBoxHaStateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchCloudBoxHaStateAsyncHandler;
+			typedef Outcome<Error, Model::UnbindSmartAccessGatewayResult> UnbindSmartAccessGatewayOutcome;
+			typedef std::future<UnbindSmartAccessGatewayOutcome> UnbindSmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::UnbindSmartAccessGatewayRequest&, const UnbindSmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnbindSmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::CreateSmartAccessGatewayResult> CreateSmartAccessGatewayOutcome;
+			typedef std::future<CreateSmartAccessGatewayOutcome> CreateSmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::CreateSmartAccessGatewayRequest&, const CreateSmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDedicatedLineBackupResult> DeleteDedicatedLineBackupOutcome;
+			typedef std::future<DeleteDedicatedLineBackupOutcome> DeleteDedicatedLineBackupOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DeleteDedicatedLineBackupRequest&, const DeleteDedicatedLineBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDedicatedLineBackupAsyncHandler;
+			typedef Outcome<Error, Model::UnlockSmartAccessGatewayResult> UnlockSmartAccessGatewayOutcome;
+			typedef std::future<UnlockSmartAccessGatewayOutcome> UnlockSmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::UnlockSmartAccessGatewayRequest&, const UnlockSmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnlockSmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::ActivateSmartAccessGatewayResult> ActivateSmartAccessGatewayOutcome;
+			typedef std::future<ActivateSmartAccessGatewayOutcome> ActivateSmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::ActivateSmartAccessGatewayRequest&, const ActivateSmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateSmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::CreateDedicatedLineBackupResult> CreateDedicatedLineBackupOutcome;
+			typedef std::future<CreateDedicatedLineBackupOutcome> CreateDedicatedLineBackupOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::CreateDedicatedLineBackupRequest&, const CreateDedicatedLineBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDedicatedLineBackupAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSmartAccessGatewayHaResult> DescribeSmartAccessGatewayHaOutcome;
+			typedef std::future<DescribeSmartAccessGatewayHaOutcome> DescribeSmartAccessGatewayHaOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DescribeSmartAccessGatewayHaRequest&, const DescribeSmartAccessGatewayHaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSmartAccessGatewayHaAsyncHandler;
+			typedef Outcome<Error, Model::ModifyCloudConnectNetworkResult> ModifyCloudConnectNetworkOutcome;
+			typedef std::future<ModifyCloudConnectNetworkOutcome> ModifyCloudConnectNetworkOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::ModifyCloudConnectNetworkRequest&, const ModifyCloudConnectNetworkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCloudConnectNetworkAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCloudConnectNetworkResult> DeleteCloudConnectNetworkOutcome;
+			typedef std::future<DeleteCloudConnectNetworkOutcome> DeleteCloudConnectNetworkOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DeleteCloudConnectNetworkRequest&, const DeleteCloudConnectNetworkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCloudConnectNetworkAsyncHandler;
+			typedef Outcome<Error, Model::CreateCloudConnectNetworkResult> CreateCloudConnectNetworkOutcome;
+			typedef std::future<CreateCloudConnectNetworkOutcome> CreateCloudConnectNetworkOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::CreateCloudConnectNetworkRequest&, const CreateCloudConnectNetworkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCloudConnectNetworkAsyncHandler;
+			typedef Outcome<Error, Model::RebootSmartAccessGatewayResult> RebootSmartAccessGatewayOutcome;
+			typedef std::future<RebootSmartAccessGatewayOutcome> RebootSmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::RebootSmartAccessGatewayRequest&, const RebootSmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebootSmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::BindSmartAccessGatewayResult> BindSmartAccessGatewayOutcome;
+			typedef std::future<BindSmartAccessGatewayOutcome> BindSmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::BindSmartAccessGatewayRequest&, const BindSmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindSmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::GetSmartAccessGatewayUseLimitResult> GetSmartAccessGatewayUseLimitOutcome;
+			typedef std::future<GetSmartAccessGatewayUseLimitOutcome> GetSmartAccessGatewayUseLimitOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::GetSmartAccessGatewayUseLimitRequest&, const GetSmartAccessGatewayUseLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSmartAccessGatewayUseLimitAsyncHandler;
+			typedef Outcome<Error, Model::ModifySmartAccessGatewayResult> ModifySmartAccessGatewayOutcome;
+			typedef std::future<ModifySmartAccessGatewayOutcome> ModifySmartAccessGatewayOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::ModifySmartAccessGatewayRequest&, const ModifySmartAccessGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySmartAccessGatewayAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCloudConnectNetworksResult> DescribeCloudConnectNetworksOutcome;
+			typedef std::future<DescribeCloudConnectNetworksOutcome> DescribeCloudConnectNetworksOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DescribeCloudConnectNetworksRequest&, const DescribeCloudConnectNetworksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCloudConnectNetworksAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSmartAccessGatewayVersionsResult> DescribeSmartAccessGatewayVersionsOutcome;
+			typedef std::future<DescribeSmartAccessGatewayVersionsOutcome> DescribeSmartAccessGatewayVersionsOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::DescribeSmartAccessGatewayVersionsRequest&, const DescribeSmartAccessGatewayVersionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSmartAccessGatewayVersionsAsyncHandler;
+			typedef Outcome<Error, Model::UpdateSmartAccessGatewayVersionResult> UpdateSmartAccessGatewayVersionOutcome;
+			typedef std::future<UpdateSmartAccessGatewayVersionOutcome> UpdateSmartAccessGatewayVersionOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::UpdateSmartAccessGatewayVersionRequest&, const UpdateSmartAccessGatewayVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSmartAccessGatewayVersionAsyncHandler;
+			typedef Outcome<Error, Model::GetCloudConnectNetworkUseLimitResult> GetCloudConnectNetworkUseLimitOutcome;
+			typedef std::future<GetCloudConnectNetworkUseLimitOutcome> GetCloudConnectNetworkUseLimitOutcomeCallable;
+			typedef std::function<void(const SmartagClient*, const Model::GetCloudConnectNetworkUseLimitRequest&, const GetCloudConnectNetworkUseLimitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCloudConnectNetworkUseLimitAsyncHandler;
+
+			SmartagClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			SmartagClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			SmartagClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~SmartagClient();
+			DescribeSmartAccessGatewaysOutcome describeSmartAccessGateways(const Model::DescribeSmartAccessGatewaysRequest &request)const;
+			void describeSmartAccessGatewaysAsync(const Model::DescribeSmartAccessGatewaysRequest& request, const DescribeSmartAccessGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSmartAccessGatewaysOutcomeCallable describeSmartAccessGatewaysCallable(const Model::DescribeSmartAccessGatewaysRequest& request) const;
+			SwitchCloudBoxHaStateOutcome switchCloudBoxHaState(const Model::SwitchCloudBoxHaStateRequest &request)const;
+			void switchCloudBoxHaStateAsync(const Model::SwitchCloudBoxHaStateRequest& request, const SwitchCloudBoxHaStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SwitchCloudBoxHaStateOutcomeCallable switchCloudBoxHaStateCallable(const Model::SwitchCloudBoxHaStateRequest& request) const;
+			UnbindSmartAccessGatewayOutcome unbindSmartAccessGateway(const Model::UnbindSmartAccessGatewayRequest &request)const;
+			void unbindSmartAccessGatewayAsync(const Model::UnbindSmartAccessGatewayRequest& request, const UnbindSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnbindSmartAccessGatewayOutcomeCallable unbindSmartAccessGatewayCallable(const Model::UnbindSmartAccessGatewayRequest& request) const;
+			CreateSmartAccessGatewayOutcome createSmartAccessGateway(const Model::CreateSmartAccessGatewayRequest &request)const;
+			void createSmartAccessGatewayAsync(const Model::CreateSmartAccessGatewayRequest& request, const CreateSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSmartAccessGatewayOutcomeCallable createSmartAccessGatewayCallable(const Model::CreateSmartAccessGatewayRequest& request) const;
+			DeleteDedicatedLineBackupOutcome deleteDedicatedLineBackup(const Model::DeleteDedicatedLineBackupRequest &request)const;
+			void deleteDedicatedLineBackupAsync(const Model::DeleteDedicatedLineBackupRequest& request, const DeleteDedicatedLineBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDedicatedLineBackupOutcomeCallable deleteDedicatedLineBackupCallable(const Model::DeleteDedicatedLineBackupRequest& request) const;
+			UnlockSmartAccessGatewayOutcome unlockSmartAccessGateway(const Model::UnlockSmartAccessGatewayRequest &request)const;
+			void unlockSmartAccessGatewayAsync(const Model::UnlockSmartAccessGatewayRequest& request, const UnlockSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnlockSmartAccessGatewayOutcomeCallable unlockSmartAccessGatewayCallable(const Model::UnlockSmartAccessGatewayRequest& request) const;
+			ActivateSmartAccessGatewayOutcome activateSmartAccessGateway(const Model::ActivateSmartAccessGatewayRequest &request)const;
+			void activateSmartAccessGatewayAsync(const Model::ActivateSmartAccessGatewayRequest& request, const ActivateSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ActivateSmartAccessGatewayOutcomeCallable activateSmartAccessGatewayCallable(const Model::ActivateSmartAccessGatewayRequest& request) const;
+			CreateDedicatedLineBackupOutcome createDedicatedLineBackup(const Model::CreateDedicatedLineBackupRequest &request)const;
+			void createDedicatedLineBackupAsync(const Model::CreateDedicatedLineBackupRequest& request, const CreateDedicatedLineBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateDedicatedLineBackupOutcomeCallable createDedicatedLineBackupCallable(const Model::CreateDedicatedLineBackupRequest& request) const;
+			DescribeSmartAccessGatewayHaOutcome describeSmartAccessGatewayHa(const Model::DescribeSmartAccessGatewayHaRequest &request)const;
+			void describeSmartAccessGatewayHaAsync(const Model::DescribeSmartAccessGatewayHaRequest& request, const DescribeSmartAccessGatewayHaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSmartAccessGatewayHaOutcomeCallable describeSmartAccessGatewayHaCallable(const Model::DescribeSmartAccessGatewayHaRequest& request) const;
+			ModifyCloudConnectNetworkOutcome modifyCloudConnectNetwork(const Model::ModifyCloudConnectNetworkRequest &request)const;
+			void modifyCloudConnectNetworkAsync(const Model::ModifyCloudConnectNetworkRequest& request, const ModifyCloudConnectNetworkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyCloudConnectNetworkOutcomeCallable modifyCloudConnectNetworkCallable(const Model::ModifyCloudConnectNetworkRequest& request) const;
+			DeleteCloudConnectNetworkOutcome deleteCloudConnectNetwork(const Model::DeleteCloudConnectNetworkRequest &request)const;
+			void deleteCloudConnectNetworkAsync(const Model::DeleteCloudConnectNetworkRequest& request, const DeleteCloudConnectNetworkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCloudConnectNetworkOutcomeCallable deleteCloudConnectNetworkCallable(const Model::DeleteCloudConnectNetworkRequest& request) const;
+			CreateCloudConnectNetworkOutcome createCloudConnectNetwork(const Model::CreateCloudConnectNetworkRequest &request)const;
+			void createCloudConnectNetworkAsync(const Model::CreateCloudConnectNetworkRequest& request, const CreateCloudConnectNetworkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCloudConnectNetworkOutcomeCallable createCloudConnectNetworkCallable(const Model::CreateCloudConnectNetworkRequest& request) const;
+			RebootSmartAccessGatewayOutcome rebootSmartAccessGateway(const Model::RebootSmartAccessGatewayRequest &request)const;
+			void rebootSmartAccessGatewayAsync(const Model::RebootSmartAccessGatewayRequest& request, const RebootSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RebootSmartAccessGatewayOutcomeCallable rebootSmartAccessGatewayCallable(const Model::RebootSmartAccessGatewayRequest& request) const;
+			BindSmartAccessGatewayOutcome bindSmartAccessGateway(const Model::BindSmartAccessGatewayRequest &request)const;
+			void bindSmartAccessGatewayAsync(const Model::BindSmartAccessGatewayRequest& request, const BindSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BindSmartAccessGatewayOutcomeCallable bindSmartAccessGatewayCallable(const Model::BindSmartAccessGatewayRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			GetSmartAccessGatewayUseLimitOutcome getSmartAccessGatewayUseLimit(const Model::GetSmartAccessGatewayUseLimitRequest &request)const;
+			void getSmartAccessGatewayUseLimitAsync(const Model::GetSmartAccessGatewayUseLimitRequest& request, const GetSmartAccessGatewayUseLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSmartAccessGatewayUseLimitOutcomeCallable getSmartAccessGatewayUseLimitCallable(const Model::GetSmartAccessGatewayUseLimitRequest& request) const;
+			ModifySmartAccessGatewayOutcome modifySmartAccessGateway(const Model::ModifySmartAccessGatewayRequest &request)const;
+			void modifySmartAccessGatewayAsync(const Model::ModifySmartAccessGatewayRequest& request, const ModifySmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifySmartAccessGatewayOutcomeCallable modifySmartAccessGatewayCallable(const Model::ModifySmartAccessGatewayRequest& request) const;
+			DescribeCloudConnectNetworksOutcome describeCloudConnectNetworks(const Model::DescribeCloudConnectNetworksRequest &request)const;
+			void describeCloudConnectNetworksAsync(const Model::DescribeCloudConnectNetworksRequest& request, const DescribeCloudConnectNetworksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCloudConnectNetworksOutcomeCallable describeCloudConnectNetworksCallable(const Model::DescribeCloudConnectNetworksRequest& request) const;
+			DescribeSmartAccessGatewayVersionsOutcome describeSmartAccessGatewayVersions(const Model::DescribeSmartAccessGatewayVersionsRequest &request)const;
+			void describeSmartAccessGatewayVersionsAsync(const Model::DescribeSmartAccessGatewayVersionsRequest& request, const DescribeSmartAccessGatewayVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSmartAccessGatewayVersionsOutcomeCallable describeSmartAccessGatewayVersionsCallable(const Model::DescribeSmartAccessGatewayVersionsRequest& request) const;
+			UpdateSmartAccessGatewayVersionOutcome updateSmartAccessGatewayVersion(const Model::UpdateSmartAccessGatewayVersionRequest &request)const;
+			void updateSmartAccessGatewayVersionAsync(const Model::UpdateSmartAccessGatewayVersionRequest& request, const UpdateSmartAccessGatewayVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateSmartAccessGatewayVersionOutcomeCallable updateSmartAccessGatewayVersionCallable(const Model::UpdateSmartAccessGatewayVersionRequest& request) const;
+			GetCloudConnectNetworkUseLimitOutcome getCloudConnectNetworkUseLimit(const Model::GetCloudConnectNetworkUseLimitRequest &request)const;
+			void getCloudConnectNetworkUseLimitAsync(const Model::GetCloudConnectNetworkUseLimitRequest& request, const GetCloudConnectNetworkUseLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCloudConnectNetworkUseLimitOutcomeCallable getCloudConnectNetworkUseLimitCallable(const Model::GetCloudConnectNetworkUseLimitRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_SMARTAG_SMARTAGCLIENT_H_

smartag/include/alibabacloud/smartag/SmartagExport.h

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

smartag/include/alibabacloud/smartag/model/ActivateSmartAccessGatewayRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_ACTIVATESMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_ACTIVATESMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT ActivateSmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				ActivateSmartAccessGatewayRequest();
+				~ActivateSmartAccessGatewayRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_ACTIVATESMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/ActivateSmartAccessGatewayResult.h

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

smartag/include/alibabacloud/smartag/model/BindSmartAccessGatewayRequest.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_SMARTAG_MODEL_BINDSMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_BINDSMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT BindSmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				BindSmartAccessGatewayRequest();
+				~BindSmartAccessGatewayRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getCcnId()const;
+				void setCcnId(const std::string& ccnId);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string ccnId_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_BINDSMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/BindSmartAccessGatewayResult.h

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

smartag/include/alibabacloud/smartag/model/CreateCloudConnectNetworkRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_CREATECLOUDCONNECTNETWORKREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_CREATECLOUDCONNECTNETWORKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT CreateCloudConnectNetworkRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateCloudConnectNetworkRequest();
+				~CreateCloudConnectNetworkRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				bool getIsDefault()const;
+				void setIsDefault(bool isDefault);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string name_;
+				std::string description_;
+				bool isDefault_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_CREATECLOUDCONNECTNETWORKREQUEST_H_

smartag/include/alibabacloud/smartag/model/CreateCloudConnectNetworkResult.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_SMARTAG_MODEL_CREATECLOUDCONNECTNETWORKRESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_CREATECLOUDCONNECTNETWORKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT CreateCloudConnectNetworkResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCloudConnectNetworkResult();
+				explicit CreateCloudConnectNetworkResult(const std::string &payload);
+				~CreateCloudConnectNetworkResult();
+				std::string getStatus()const;
+				std::string getDescription()const;
+				std::string getCcnId()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string description_;
+				std::string ccnId_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_CREATECLOUDCONNECTNETWORKRESULT_H_

smartag/include/alibabacloud/smartag/model/CreateDedicatedLineBackupRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_CREATEDEDICATEDLINEBACKUPREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_CREATEDEDICATEDLINEBACKUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT CreateDedicatedLineBackupRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateDedicatedLineBackupRequest();
+				~CreateDedicatedLineBackupRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVbrId()const;
+				void setVbrId(const std::string& vbrId);
+				std::string getVbrRegionId()const;
+				void setVbrRegionId(const std::string& vbrRegionId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+				std::string vbrId_;
+				std::string vbrRegionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_CREATEDEDICATEDLINEBACKUPREQUEST_H_

smartag/include/alibabacloud/smartag/model/CreateDedicatedLineBackupResult.h

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

smartag/include/alibabacloud/smartag/model/CreateSmartAccessGatewayRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_CREATESMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_CREATESMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT CreateSmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateSmartAccessGatewayRequest();
+				~CreateSmartAccessGatewayRequest();
+
+				int getMaxBandWidth()const;
+				void setMaxBandWidth(int maxBandWidth);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getReceiverTown()const;
+				void setReceiverTown(const std::string& receiverTown);
+				std::string getReceiverDistrict()const;
+				void setReceiverDistrict(const std::string& receiverDistrict);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getReceiverAddress()const;
+				void setReceiverAddress(const std::string& receiverAddress);
+				std::string getBuyerMessage()const;
+				void setBuyerMessage(const std::string& buyerMessage);
+				std::string getHardWareSpec()const;
+				void setHardWareSpec(const std::string& hardWareSpec);
+				std::string getReceiverEmail()const;
+				void setReceiverEmail(const std::string& receiverEmail);
+				std::string getReceiverState()const;
+				void setReceiverState(const std::string& receiverState);
+				std::string getReceiverCity()const;
+				void setReceiverCity(const std::string& receiverCity);
+				int getPeriod()const;
+				void setPeriod(int period);
+				bool getAutoPay()const;
+				void setAutoPay(bool autoPay);
+				std::string getReceiverMobile()const;
+				void setReceiverMobile(const std::string& receiverMobile);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getReceiverPhone()const;
+				void setReceiverPhone(const std::string& receiverPhone);
+				std::string getReceiverName()const;
+				void setReceiverName(const std::string& receiverName);
+				std::string getHaType()const;
+				void setHaType(const std::string& haType);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getReceiverCountry()const;
+				void setReceiverCountry(const std::string& receiverCountry);
+				std::string getChargeType()const;
+				void setChargeType(const std::string& chargeType);
+				std::string getReceiverZip()const;
+				void setReceiverZip(const std::string& receiverZip);
+
+            private:
+				int maxBandWidth_;
+				long resourceOwnerId_;
+				std::string description_;
+				std::string receiverTown_;
+				std::string receiverDistrict_;
+				std::string regionId_;
+				std::string receiverAddress_;
+				std::string buyerMessage_;
+				std::string hardWareSpec_;
+				std::string receiverEmail_;
+				std::string receiverState_;
+				std::string receiverCity_;
+				int period_;
+				bool autoPay_;
+				std::string receiverMobile_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string receiverPhone_;
+				std::string receiverName_;
+				std::string haType_;
+				std::string name_;
+				std::string receiverCountry_;
+				std::string chargeType_;
+				std::string receiverZip_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_CREATESMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/CreateSmartAccessGatewayResult.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_SMARTAG_MODEL_CREATESMARTACCESSGATEWAYRESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_CREATESMARTACCESSGATEWAYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT CreateSmartAccessGatewayResult : public ServiceResult
+			{
+			public:
+
+
+				CreateSmartAccessGatewayResult();
+				explicit CreateSmartAccessGatewayResult(const std::string &payload);
+				~CreateSmartAccessGatewayResult();
+				std::string getDescription()const;
+				std::string getSmartAGId()const;
+				std::string getOrderId()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string description_;
+				std::string smartAGId_;
+				std::string orderId_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_CREATESMARTACCESSGATEWAYRESULT_H_

smartag/include/alibabacloud/smartag/model/DeleteCloudConnectNetworkRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_DELETECLOUDCONNECTNETWORKREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DELETECLOUDCONNECTNETWORKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DeleteCloudConnectNetworkRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteCloudConnectNetworkRequest();
+				~DeleteCloudConnectNetworkRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getCcnId()const;
+				void setCcnId(const std::string& ccnId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string ccnId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DELETECLOUDCONNECTNETWORKREQUEST_H_

smartag/include/alibabacloud/smartag/model/DeleteCloudConnectNetworkResult.h

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

smartag/include/alibabacloud/smartag/model/DeleteDedicatedLineBackupRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_DELETEDEDICATEDLINEBACKUPREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DELETEDEDICATEDLINEBACKUPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DeleteDedicatedLineBackupRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteDedicatedLineBackupRequest();
+				~DeleteDedicatedLineBackupRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DELETEDEDICATEDLINEBACKUPREQUEST_H_

smartag/include/alibabacloud/smartag/model/DeleteDedicatedLineBackupResult.h

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

smartag/include/alibabacloud/smartag/model/DescribeCloudConnectNetworksRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_DESCRIBECLOUDCONNECTNETWORKSREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBECLOUDCONNECTNETWORKSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeCloudConnectNetworksRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCloudConnectNetworksRequest();
+				~DescribeCloudConnectNetworksRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getCcnId()const;
+				void setCcnId(const std::string& ccnId);
+				std::string getPageSize()const;
+				void setPageSize(const std::string& pageSize);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getPageNumber()const;
+				void setPageNumber(const std::string& pageNumber);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string name_;
+				std::string ccnId_;
+				std::string pageSize_;
+				long ownerId_;
+				std::string pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBECLOUDCONNECTNETWORKSREQUEST_H_

smartag/include/alibabacloud/smartag/model/DescribeCloudConnectNetworksResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_DESCRIBECLOUDCONNECTNETWORKSRESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBECLOUDCONNECTNETWORKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeCloudConnectNetworksResult : public ServiceResult
+			{
+			public:
+				struct CloudConnectNetwork
+				{
+					bool isDefault;
+					std::string description;
+					std::string ccnId;
+					std::string availableCloudBoxCount;
+					long createTime;
+					std::string associatedCenOwnerId;
+					std::string associatedCenId;
+					std::string associatedCloudBoxCount;
+					std::string name;
+				};
+
+
+				DescribeCloudConnectNetworksResult();
+				explicit DescribeCloudConnectNetworksResult(const std::string &payload);
+				~DescribeCloudConnectNetworksResult();
+				std::vector<CloudConnectNetwork> getCloudConnectNetworks()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<CloudConnectNetwork> cloudConnectNetworks_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBECLOUDCONNECTNETWORKSRESULT_H_

smartag/include/alibabacloud/smartag/model/DescribeRegionsRequest.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_SMARTAG_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeRegionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRegionsRequest();
+				~DescribeRegionsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getAcceptLanguage()const;
+				void setAcceptLanguage(const std::string& acceptLanguage);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string acceptLanguage_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBEREGIONSREQUEST_H_

smartag/include/alibabacloud/smartag/model/DescribeRegionsResult.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_SMARTAG_MODEL_DESCRIBEREGIONSRESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBEREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeRegionsResult : public ServiceResult
+			{
+			public:
+				struct Region
+				{
+					std::string regionId;
+					std::string regionEndpoint;
+					std::string localName;
+				};
+
+
+				DescribeRegionsResult();
+				explicit DescribeRegionsResult(const std::string &payload);
+				~DescribeRegionsResult();
+				std::vector<Region> getRegions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Region> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBEREGIONSRESULT_H_

smartag/include/alibabacloud/smartag/model/DescribeSmartAccessGatewayHaRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYHAREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYHAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeSmartAccessGatewayHaRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSmartAccessGatewayHaRequest();
+				~DescribeSmartAccessGatewayHaRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYHAREQUEST_H_

smartag/include/alibabacloud/smartag/model/DescribeSmartAccessGatewayHaResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYHARESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYHARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeSmartAccessGatewayHaResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeSmartAccessGatewayHaResult();
+				explicit DescribeSmartAccessGatewayHaResult(const std::string &payload);
+				~DescribeSmartAccessGatewayHaResult();
+				std::string getDeviceLevelBackupState()const;
+				std::string getBackupLinkId()const;
+				std::string getBackupDeviceId()const;
+				std::string getLinkLevelBackupType()const;
+				std::string getMainLinkId()const;
+				std::string getSmartAGId()const;
+				std::string getDeviceLevelBackupType()const;
+				std::string getLinkLevelBackupState()const;
+				std::string getMainDeviceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string deviceLevelBackupState_;
+				std::string backupLinkId_;
+				std::string backupDeviceId_;
+				std::string linkLevelBackupType_;
+				std::string mainLinkId_;
+				std::string smartAGId_;
+				std::string deviceLevelBackupType_;
+				std::string linkLevelBackupState_;
+				std::string mainDeviceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYHARESULT_H_

smartag/include/alibabacloud/smartag/model/DescribeSmartAccessGatewayVersionsRequest.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_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYVERSIONSREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYVERSIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeSmartAccessGatewayVersionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSmartAccessGatewayVersionsRequest();
+				~DescribeSmartAccessGatewayVersionsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYVERSIONSREQUEST_H_

smartag/include/alibabacloud/smartag/model/DescribeSmartAccessGatewayVersionsResult.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_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYVERSIONSRESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYVERSIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeSmartAccessGatewayVersionsResult : public ServiceResult
+			{
+			public:
+				struct SmartAGVersion
+				{
+					std::string versionCode;
+					long createTime;
+					std::string versionName;
+				};
+
+
+				DescribeSmartAccessGatewayVersionsResult();
+				explicit DescribeSmartAccessGatewayVersionsResult(const std::string &payload);
+				~DescribeSmartAccessGatewayVersionsResult();
+				std::vector<SmartAGVersion> getSmartAGVersions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SmartAGVersion> smartAGVersions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYVERSIONSRESULT_H_

smartag/include/alibabacloud/smartag/model/DescribeSmartAccessGatewaysRequest.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_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYSREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeSmartAccessGatewaysRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSmartAccessGatewaysRequest();
+				~DescribeSmartAccessGatewaysRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getPageSize()const;
+				void setPageSize(const std::string& pageSize);
+				std::string getAssociatedCcnId()const;
+				void setAssociatedCcnId(const std::string& associatedCcnId);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getPageNumber()const;
+				void setPageNumber(const std::string& pageNumber);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string name_;
+				std::string pageSize_;
+				std::string associatedCcnId_;
+				std::string smartAGId_;
+				long ownerId_;
+				std::string pageNumber_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYSREQUEST_H_

smartag/include/alibabacloud/smartag/model/DescribeSmartAccessGatewaysResult.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYSRESULT_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT DescribeSmartAccessGatewaysResult : public ServiceResult
+			{
+			public:
+				struct SmartAccessGateway
+				{
+					std::string status;
+					std::string description;
+					long endTime;
+					std::string maxBandwidth;
+					std::string associatedCcnName;
+					long createTime;
+					std::string cidrBlock;
+					std::string city;
+					std::string hardwareVersion;
+					std::string name;
+					std::string softwareVersion;
+					std::string serialNumber;
+					std::string associatedCcnId;
+					std::string smartAGId;
+					int securityLockThreshold;
+				};
+
+
+				DescribeSmartAccessGatewaysResult();
+				explicit DescribeSmartAccessGatewaysResult(const std::string &payload);
+				~DescribeSmartAccessGatewaysResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<SmartAccessGateway> getSmartAccessGateways()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<SmartAccessGateway> smartAccessGateways_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_DESCRIBESMARTACCESSGATEWAYSRESULT_H_

smartag/include/alibabacloud/smartag/model/GetCloudConnectNetworkUseLimitRequest.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_SMARTAG_MODEL_GETCLOUDCONNECTNETWORKUSELIMITREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_GETCLOUDCONNECTNETWORKUSELIMITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT GetCloudConnectNetworkUseLimitRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetCloudConnectNetworkUseLimitRequest();
+				~GetCloudConnectNetworkUseLimitRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_GETCLOUDCONNECTNETWORKUSELIMITREQUEST_H_

smartag/include/alibabacloud/smartag/model/GetCloudConnectNetworkUseLimitResult.h

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

smartag/include/alibabacloud/smartag/model/GetSmartAccessGatewayUseLimitRequest.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_SMARTAG_MODEL_GETSMARTACCESSGATEWAYUSELIMITREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_GETSMARTACCESSGATEWAYUSELIMITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT GetSmartAccessGatewayUseLimitRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetSmartAccessGatewayUseLimitRequest();
+				~GetSmartAccessGatewayUseLimitRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_GETSMARTACCESSGATEWAYUSELIMITREQUEST_H_

smartag/include/alibabacloud/smartag/model/GetSmartAccessGatewayUseLimitResult.h

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

smartag/include/alibabacloud/smartag/model/ModifyCloudConnectNetworkRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_MODIFYCLOUDCONNECTNETWORKREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_MODIFYCLOUDCONNECTNETWORKREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT ModifyCloudConnectNetworkRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyCloudConnectNetworkRequest();
+				~ModifyCloudConnectNetworkRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getCcnId()const;
+				void setCcnId(const std::string& ccnId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string ccnId_;
+				std::string name_;
+				std::string description_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_MODIFYCLOUDCONNECTNETWORKREQUEST_H_

smartag/include/alibabacloud/smartag/model/ModifyCloudConnectNetworkResult.h

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

smartag/include/alibabacloud/smartag/model/ModifySmartAccessGatewayRequest.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_SMARTAG_MODEL_MODIFYSMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_MODIFYSMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT ModifySmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifySmartAccessGatewayRequest();
+				~ModifySmartAccessGatewayRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getCity()const;
+				void setCity(const std::string& city);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getCidrBlock()const;
+				void setCidrBlock(const std::string& cidrBlock);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getSecurityLockThreshold()const;
+				void setSecurityLockThreshold(int securityLockThreshold);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string city_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string name_;
+				std::string cidrBlock_;
+				std::string smartAGId_;
+				std::string description_;
+				long ownerId_;
+				int securityLockThreshold_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_MODIFYSMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/ModifySmartAccessGatewayResult.h

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

smartag/include/alibabacloud/smartag/model/RebootSmartAccessGatewayRequest.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_SMARTAG_MODEL_REBOOTSMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_REBOOTSMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT RebootSmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				RebootSmartAccessGatewayRequest();
+				~RebootSmartAccessGatewayRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getSerialNumber()const;
+				void setSerialNumber(const std::string& serialNumber);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string serialNumber_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_REBOOTSMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/RebootSmartAccessGatewayResult.h

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

smartag/include/alibabacloud/smartag/model/SwitchCloudBoxHaStateRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_SWITCHCLOUDBOXHASTATEREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_SWITCHCLOUDBOXHASTATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT SwitchCloudBoxHaStateRequest : public RpcServiceRequest
+			{
+
+			public:
+				SwitchCloudBoxHaStateRequest();
+				~SwitchCloudBoxHaStateRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_SWITCHCLOUDBOXHASTATEREQUEST_H_

smartag/include/alibabacloud/smartag/model/SwitchCloudBoxHaStateResult.h

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

smartag/include/alibabacloud/smartag/model/UnbindSmartAccessGatewayRequest.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_SMARTAG_MODEL_UNBINDSMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_UNBINDSMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT UnbindSmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				UnbindSmartAccessGatewayRequest();
+				~UnbindSmartAccessGatewayRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getCcnId()const;
+				void setCcnId(const std::string& ccnId);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string ccnId_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_UNBINDSMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/UnbindSmartAccessGatewayResult.h

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

smartag/include/alibabacloud/smartag/model/UnlockSmartAccessGatewayRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SMARTAG_MODEL_UNLOCKSMARTACCESSGATEWAYREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_UNLOCKSMARTACCESSGATEWAYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT UnlockSmartAccessGatewayRequest : public RpcServiceRequest
+			{
+
+			public:
+				UnlockSmartAccessGatewayRequest();
+				~UnlockSmartAccessGatewayRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_UNLOCKSMARTACCESSGATEWAYREQUEST_H_

smartag/include/alibabacloud/smartag/model/UnlockSmartAccessGatewayResult.h

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

smartag/include/alibabacloud/smartag/model/UpdateSmartAccessGatewayVersionRequest.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_SMARTAG_MODEL_UPDATESMARTACCESSGATEWAYVERSIONREQUEST_H_
+#define ALIBABACLOUD_SMARTAG_MODEL_UPDATESMARTACCESSGATEWAYVERSIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/smartag/SmartagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Smartag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SMARTAG_EXPORT UpdateSmartAccessGatewayVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateSmartAccessGatewayVersionRequest();
+				~UpdateSmartAccessGatewayVersionRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getSmartAGId()const;
+				void setSmartAGId(const std::string& smartAGId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersionCode()const;
+				void setVersionCode(const std::string& versionCode);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string regionId_;
+				std::string ownerAccount_;
+				std::string smartAGId_;
+				long ownerId_;
+				std::string versionCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SMARTAG_MODEL_UPDATESMARTACCESSGATEWAYVERSIONREQUEST_H_

smartag/include/alibabacloud/smartag/model/UpdateSmartAccessGatewayVersionResult.h

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

smartag/src/SmartagClient.cc

@@ -0,0 +1,809 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/SmartagClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Smartag;
+using namespace AlibabaCloud::Smartag::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "Smartag";
+}
+
+SmartagClient::SmartagClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "smartag");
+}
+
+SmartagClient::SmartagClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "smartag");
+}
+
+SmartagClient::SmartagClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "smartag");
+}
+
+SmartagClient::~SmartagClient()
+{}
+
+SmartagClient::DescribeSmartAccessGatewaysOutcome SmartagClient::describeSmartAccessGateways(const DescribeSmartAccessGatewaysRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSmartAccessGatewaysOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSmartAccessGatewaysOutcome(DescribeSmartAccessGatewaysResult(outcome.result()));
+	else
+		return DescribeSmartAccessGatewaysOutcome(outcome.error());
+}
+
+void SmartagClient::describeSmartAccessGatewaysAsync(const DescribeSmartAccessGatewaysRequest& request, const DescribeSmartAccessGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSmartAccessGateways(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DescribeSmartAccessGatewaysOutcomeCallable SmartagClient::describeSmartAccessGatewaysCallable(const DescribeSmartAccessGatewaysRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSmartAccessGatewaysOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSmartAccessGateways(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::SwitchCloudBoxHaStateOutcome SmartagClient::switchCloudBoxHaState(const SwitchCloudBoxHaStateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SwitchCloudBoxHaStateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SwitchCloudBoxHaStateOutcome(SwitchCloudBoxHaStateResult(outcome.result()));
+	else
+		return SwitchCloudBoxHaStateOutcome(outcome.error());
+}
+
+void SmartagClient::switchCloudBoxHaStateAsync(const SwitchCloudBoxHaStateRequest& request, const SwitchCloudBoxHaStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, switchCloudBoxHaState(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::SwitchCloudBoxHaStateOutcomeCallable SmartagClient::switchCloudBoxHaStateCallable(const SwitchCloudBoxHaStateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SwitchCloudBoxHaStateOutcome()>>(
+			[this, request]()
+			{
+			return this->switchCloudBoxHaState(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::UnbindSmartAccessGatewayOutcome SmartagClient::unbindSmartAccessGateway(const UnbindSmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UnbindSmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UnbindSmartAccessGatewayOutcome(UnbindSmartAccessGatewayResult(outcome.result()));
+	else
+		return UnbindSmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::unbindSmartAccessGatewayAsync(const UnbindSmartAccessGatewayRequest& request, const UnbindSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, unbindSmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::UnbindSmartAccessGatewayOutcomeCallable SmartagClient::unbindSmartAccessGatewayCallable(const UnbindSmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UnbindSmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->unbindSmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::CreateSmartAccessGatewayOutcome SmartagClient::createSmartAccessGateway(const CreateSmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateSmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateSmartAccessGatewayOutcome(CreateSmartAccessGatewayResult(outcome.result()));
+	else
+		return CreateSmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::createSmartAccessGatewayAsync(const CreateSmartAccessGatewayRequest& request, const CreateSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::CreateSmartAccessGatewayOutcomeCallable SmartagClient::createSmartAccessGatewayCallable(const CreateSmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateSmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->createSmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::DeleteDedicatedLineBackupOutcome SmartagClient::deleteDedicatedLineBackup(const DeleteDedicatedLineBackupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDedicatedLineBackupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDedicatedLineBackupOutcome(DeleteDedicatedLineBackupResult(outcome.result()));
+	else
+		return DeleteDedicatedLineBackupOutcome(outcome.error());
+}
+
+void SmartagClient::deleteDedicatedLineBackupAsync(const DeleteDedicatedLineBackupRequest& request, const DeleteDedicatedLineBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDedicatedLineBackup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DeleteDedicatedLineBackupOutcomeCallable SmartagClient::deleteDedicatedLineBackupCallable(const DeleteDedicatedLineBackupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDedicatedLineBackupOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDedicatedLineBackup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::UnlockSmartAccessGatewayOutcome SmartagClient::unlockSmartAccessGateway(const UnlockSmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UnlockSmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UnlockSmartAccessGatewayOutcome(UnlockSmartAccessGatewayResult(outcome.result()));
+	else
+		return UnlockSmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::unlockSmartAccessGatewayAsync(const UnlockSmartAccessGatewayRequest& request, const UnlockSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, unlockSmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::UnlockSmartAccessGatewayOutcomeCallable SmartagClient::unlockSmartAccessGatewayCallable(const UnlockSmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UnlockSmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->unlockSmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::ActivateSmartAccessGatewayOutcome SmartagClient::activateSmartAccessGateway(const ActivateSmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ActivateSmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ActivateSmartAccessGatewayOutcome(ActivateSmartAccessGatewayResult(outcome.result()));
+	else
+		return ActivateSmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::activateSmartAccessGatewayAsync(const ActivateSmartAccessGatewayRequest& request, const ActivateSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, activateSmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::ActivateSmartAccessGatewayOutcomeCallable SmartagClient::activateSmartAccessGatewayCallable(const ActivateSmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ActivateSmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->activateSmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::CreateDedicatedLineBackupOutcome SmartagClient::createDedicatedLineBackup(const CreateDedicatedLineBackupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDedicatedLineBackupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDedicatedLineBackupOutcome(CreateDedicatedLineBackupResult(outcome.result()));
+	else
+		return CreateDedicatedLineBackupOutcome(outcome.error());
+}
+
+void SmartagClient::createDedicatedLineBackupAsync(const CreateDedicatedLineBackupRequest& request, const CreateDedicatedLineBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDedicatedLineBackup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::CreateDedicatedLineBackupOutcomeCallable SmartagClient::createDedicatedLineBackupCallable(const CreateDedicatedLineBackupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDedicatedLineBackupOutcome()>>(
+			[this, request]()
+			{
+			return this->createDedicatedLineBackup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::DescribeSmartAccessGatewayHaOutcome SmartagClient::describeSmartAccessGatewayHa(const DescribeSmartAccessGatewayHaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSmartAccessGatewayHaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSmartAccessGatewayHaOutcome(DescribeSmartAccessGatewayHaResult(outcome.result()));
+	else
+		return DescribeSmartAccessGatewayHaOutcome(outcome.error());
+}
+
+void SmartagClient::describeSmartAccessGatewayHaAsync(const DescribeSmartAccessGatewayHaRequest& request, const DescribeSmartAccessGatewayHaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSmartAccessGatewayHa(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DescribeSmartAccessGatewayHaOutcomeCallable SmartagClient::describeSmartAccessGatewayHaCallable(const DescribeSmartAccessGatewayHaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSmartAccessGatewayHaOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSmartAccessGatewayHa(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::ModifyCloudConnectNetworkOutcome SmartagClient::modifyCloudConnectNetwork(const ModifyCloudConnectNetworkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyCloudConnectNetworkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyCloudConnectNetworkOutcome(ModifyCloudConnectNetworkResult(outcome.result()));
+	else
+		return ModifyCloudConnectNetworkOutcome(outcome.error());
+}
+
+void SmartagClient::modifyCloudConnectNetworkAsync(const ModifyCloudConnectNetworkRequest& request, const ModifyCloudConnectNetworkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyCloudConnectNetwork(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::ModifyCloudConnectNetworkOutcomeCallable SmartagClient::modifyCloudConnectNetworkCallable(const ModifyCloudConnectNetworkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyCloudConnectNetworkOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyCloudConnectNetwork(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::DeleteCloudConnectNetworkOutcome SmartagClient::deleteCloudConnectNetwork(const DeleteCloudConnectNetworkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteCloudConnectNetworkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteCloudConnectNetworkOutcome(DeleteCloudConnectNetworkResult(outcome.result()));
+	else
+		return DeleteCloudConnectNetworkOutcome(outcome.error());
+}
+
+void SmartagClient::deleteCloudConnectNetworkAsync(const DeleteCloudConnectNetworkRequest& request, const DeleteCloudConnectNetworkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteCloudConnectNetwork(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DeleteCloudConnectNetworkOutcomeCallable SmartagClient::deleteCloudConnectNetworkCallable(const DeleteCloudConnectNetworkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteCloudConnectNetworkOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteCloudConnectNetwork(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::CreateCloudConnectNetworkOutcome SmartagClient::createCloudConnectNetwork(const CreateCloudConnectNetworkRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCloudConnectNetworkOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCloudConnectNetworkOutcome(CreateCloudConnectNetworkResult(outcome.result()));
+	else
+		return CreateCloudConnectNetworkOutcome(outcome.error());
+}
+
+void SmartagClient::createCloudConnectNetworkAsync(const CreateCloudConnectNetworkRequest& request, const CreateCloudConnectNetworkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCloudConnectNetwork(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::CreateCloudConnectNetworkOutcomeCallable SmartagClient::createCloudConnectNetworkCallable(const CreateCloudConnectNetworkRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCloudConnectNetworkOutcome()>>(
+			[this, request]()
+			{
+			return this->createCloudConnectNetwork(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::RebootSmartAccessGatewayOutcome SmartagClient::rebootSmartAccessGateway(const RebootSmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RebootSmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RebootSmartAccessGatewayOutcome(RebootSmartAccessGatewayResult(outcome.result()));
+	else
+		return RebootSmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::rebootSmartAccessGatewayAsync(const RebootSmartAccessGatewayRequest& request, const RebootSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rebootSmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::RebootSmartAccessGatewayOutcomeCallable SmartagClient::rebootSmartAccessGatewayCallable(const RebootSmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RebootSmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->rebootSmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::BindSmartAccessGatewayOutcome SmartagClient::bindSmartAccessGateway(const BindSmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BindSmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BindSmartAccessGatewayOutcome(BindSmartAccessGatewayResult(outcome.result()));
+	else
+		return BindSmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::bindSmartAccessGatewayAsync(const BindSmartAccessGatewayRequest& request, const BindSmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, bindSmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::BindSmartAccessGatewayOutcomeCallable SmartagClient::bindSmartAccessGatewayCallable(const BindSmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BindSmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->bindSmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::DescribeRegionsOutcome SmartagClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void SmartagClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DescribeRegionsOutcomeCallable SmartagClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::GetSmartAccessGatewayUseLimitOutcome SmartagClient::getSmartAccessGatewayUseLimit(const GetSmartAccessGatewayUseLimitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetSmartAccessGatewayUseLimitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetSmartAccessGatewayUseLimitOutcome(GetSmartAccessGatewayUseLimitResult(outcome.result()));
+	else
+		return GetSmartAccessGatewayUseLimitOutcome(outcome.error());
+}
+
+void SmartagClient::getSmartAccessGatewayUseLimitAsync(const GetSmartAccessGatewayUseLimitRequest& request, const GetSmartAccessGatewayUseLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getSmartAccessGatewayUseLimit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::GetSmartAccessGatewayUseLimitOutcomeCallable SmartagClient::getSmartAccessGatewayUseLimitCallable(const GetSmartAccessGatewayUseLimitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetSmartAccessGatewayUseLimitOutcome()>>(
+			[this, request]()
+			{
+			return this->getSmartAccessGatewayUseLimit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::ModifySmartAccessGatewayOutcome SmartagClient::modifySmartAccessGateway(const ModifySmartAccessGatewayRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifySmartAccessGatewayOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifySmartAccessGatewayOutcome(ModifySmartAccessGatewayResult(outcome.result()));
+	else
+		return ModifySmartAccessGatewayOutcome(outcome.error());
+}
+
+void SmartagClient::modifySmartAccessGatewayAsync(const ModifySmartAccessGatewayRequest& request, const ModifySmartAccessGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifySmartAccessGateway(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::ModifySmartAccessGatewayOutcomeCallable SmartagClient::modifySmartAccessGatewayCallable(const ModifySmartAccessGatewayRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifySmartAccessGatewayOutcome()>>(
+			[this, request]()
+			{
+			return this->modifySmartAccessGateway(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::DescribeCloudConnectNetworksOutcome SmartagClient::describeCloudConnectNetworks(const DescribeCloudConnectNetworksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCloudConnectNetworksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCloudConnectNetworksOutcome(DescribeCloudConnectNetworksResult(outcome.result()));
+	else
+		return DescribeCloudConnectNetworksOutcome(outcome.error());
+}
+
+void SmartagClient::describeCloudConnectNetworksAsync(const DescribeCloudConnectNetworksRequest& request, const DescribeCloudConnectNetworksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCloudConnectNetworks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DescribeCloudConnectNetworksOutcomeCallable SmartagClient::describeCloudConnectNetworksCallable(const DescribeCloudConnectNetworksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCloudConnectNetworksOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCloudConnectNetworks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::DescribeSmartAccessGatewayVersionsOutcome SmartagClient::describeSmartAccessGatewayVersions(const DescribeSmartAccessGatewayVersionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSmartAccessGatewayVersionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSmartAccessGatewayVersionsOutcome(DescribeSmartAccessGatewayVersionsResult(outcome.result()));
+	else
+		return DescribeSmartAccessGatewayVersionsOutcome(outcome.error());
+}
+
+void SmartagClient::describeSmartAccessGatewayVersionsAsync(const DescribeSmartAccessGatewayVersionsRequest& request, const DescribeSmartAccessGatewayVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSmartAccessGatewayVersions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::DescribeSmartAccessGatewayVersionsOutcomeCallable SmartagClient::describeSmartAccessGatewayVersionsCallable(const DescribeSmartAccessGatewayVersionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSmartAccessGatewayVersionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSmartAccessGatewayVersions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::UpdateSmartAccessGatewayVersionOutcome SmartagClient::updateSmartAccessGatewayVersion(const UpdateSmartAccessGatewayVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateSmartAccessGatewayVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateSmartAccessGatewayVersionOutcome(UpdateSmartAccessGatewayVersionResult(outcome.result()));
+	else
+		return UpdateSmartAccessGatewayVersionOutcome(outcome.error());
+}
+
+void SmartagClient::updateSmartAccessGatewayVersionAsync(const UpdateSmartAccessGatewayVersionRequest& request, const UpdateSmartAccessGatewayVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateSmartAccessGatewayVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::UpdateSmartAccessGatewayVersionOutcomeCallable SmartagClient::updateSmartAccessGatewayVersionCallable(const UpdateSmartAccessGatewayVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateSmartAccessGatewayVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->updateSmartAccessGatewayVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SmartagClient::GetCloudConnectNetworkUseLimitOutcome SmartagClient::getCloudConnectNetworkUseLimit(const GetCloudConnectNetworkUseLimitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetCloudConnectNetworkUseLimitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetCloudConnectNetworkUseLimitOutcome(GetCloudConnectNetworkUseLimitResult(outcome.result()));
+	else
+		return GetCloudConnectNetworkUseLimitOutcome(outcome.error());
+}
+
+void SmartagClient::getCloudConnectNetworkUseLimitAsync(const GetCloudConnectNetworkUseLimitRequest& request, const GetCloudConnectNetworkUseLimitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getCloudConnectNetworkUseLimit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SmartagClient::GetCloudConnectNetworkUseLimitOutcomeCallable SmartagClient::getCloudConnectNetworkUseLimitCallable(const GetCloudConnectNetworkUseLimitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetCloudConnectNetworkUseLimitOutcome()>>(
+			[this, request]()
+			{
+			return this->getCloudConnectNetworkUseLimit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

smartag/src/model/ActivateSmartAccessGatewayRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/ActivateSmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::ActivateSmartAccessGatewayRequest;
+
+ActivateSmartAccessGatewayRequest::ActivateSmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "ActivateSmartAccessGateway")
+{}
+
+ActivateSmartAccessGatewayRequest::~ActivateSmartAccessGatewayRequest()
+{}
+
+long ActivateSmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ActivateSmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ActivateSmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ActivateSmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ActivateSmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ActivateSmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ActivateSmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ActivateSmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string ActivateSmartAccessGatewayRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void ActivateSmartAccessGatewayRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long ActivateSmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ActivateSmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/ActivateSmartAccessGatewayResult.cc

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

smartag/src/model/BindSmartAccessGatewayRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/BindSmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::BindSmartAccessGatewayRequest;
+
+BindSmartAccessGatewayRequest::BindSmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "BindSmartAccessGateway")
+{}
+
+BindSmartAccessGatewayRequest::~BindSmartAccessGatewayRequest()
+{}
+
+long BindSmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void BindSmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string BindSmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void BindSmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string BindSmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void BindSmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string BindSmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void BindSmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string BindSmartAccessGatewayRequest::getCcnId()const
+{
+	return ccnId_;
+}
+
+void BindSmartAccessGatewayRequest::setCcnId(const std::string& ccnId)
+{
+	ccnId_ = ccnId;
+	setParameter("CcnId", ccnId);
+}
+
+std::string BindSmartAccessGatewayRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void BindSmartAccessGatewayRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long BindSmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void BindSmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/BindSmartAccessGatewayResult.cc

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

smartag/src/model/CreateCloudConnectNetworkRequest.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/CreateCloudConnectNetworkRequest.h>
+
+using AlibabaCloud::Smartag::Model::CreateCloudConnectNetworkRequest;
+
+CreateCloudConnectNetworkRequest::CreateCloudConnectNetworkRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "CreateCloudConnectNetwork")
+{}
+
+CreateCloudConnectNetworkRequest::~CreateCloudConnectNetworkRequest()
+{}
+
+long CreateCloudConnectNetworkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateCloudConnectNetworkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateCloudConnectNetworkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateCloudConnectNetworkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateCloudConnectNetworkRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateCloudConnectNetworkRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateCloudConnectNetworkRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateCloudConnectNetworkRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateCloudConnectNetworkRequest::getName()const
+{
+	return name_;
+}
+
+void CreateCloudConnectNetworkRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string CreateCloudConnectNetworkRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateCloudConnectNetworkRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+bool CreateCloudConnectNetworkRequest::getIsDefault()const
+{
+	return isDefault_;
+}
+
+void CreateCloudConnectNetworkRequest::setIsDefault(bool isDefault)
+{
+	isDefault_ = isDefault;
+	setParameter("IsDefault", std::to_string(isDefault));
+}
+
+long CreateCloudConnectNetworkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateCloudConnectNetworkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/CreateCloudConnectNetworkResult.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/smartag/model/CreateCloudConnectNetworkResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Smartag;
+using namespace AlibabaCloud::Smartag::Model;
+
+CreateCloudConnectNetworkResult::CreateCloudConnectNetworkResult() :
+	ServiceResult()
+{}
+
+CreateCloudConnectNetworkResult::CreateCloudConnectNetworkResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCloudConnectNetworkResult::~CreateCloudConnectNetworkResult()
+{}
+
+void CreateCloudConnectNetworkResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["CcnId"].isNull())
+		ccnId_ = value["CcnId"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+
+}
+
+std::string CreateCloudConnectNetworkResult::getStatus()const
+{
+	return status_;
+}
+
+std::string CreateCloudConnectNetworkResult::getDescription()const
+{
+	return description_;
+}
+
+std::string CreateCloudConnectNetworkResult::getCcnId()const
+{
+	return ccnId_;
+}
+
+std::string CreateCloudConnectNetworkResult::getName()const
+{
+	return name_;
+}
+

smartag/src/model/CreateDedicatedLineBackupRequest.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/CreateDedicatedLineBackupRequest.h>
+
+using AlibabaCloud::Smartag::Model::CreateDedicatedLineBackupRequest;
+
+CreateDedicatedLineBackupRequest::CreateDedicatedLineBackupRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "CreateDedicatedLineBackup")
+{}
+
+CreateDedicatedLineBackupRequest::~CreateDedicatedLineBackupRequest()
+{}
+
+long CreateDedicatedLineBackupRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateDedicatedLineBackupRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateDedicatedLineBackupRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateDedicatedLineBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateDedicatedLineBackupRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateDedicatedLineBackupRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateDedicatedLineBackupRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateDedicatedLineBackupRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string CreateDedicatedLineBackupRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void CreateDedicatedLineBackupRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long CreateDedicatedLineBackupRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateDedicatedLineBackupRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateDedicatedLineBackupRequest::getVbrId()const
+{
+	return vbrId_;
+}
+
+void CreateDedicatedLineBackupRequest::setVbrId(const std::string& vbrId)
+{
+	vbrId_ = vbrId;
+	setParameter("VbrId", vbrId);
+}
+
+std::string CreateDedicatedLineBackupRequest::getVbrRegionId()const
+{
+	return vbrRegionId_;
+}
+
+void CreateDedicatedLineBackupRequest::setVbrRegionId(const std::string& vbrRegionId)
+{
+	vbrRegionId_ = vbrRegionId;
+	setParameter("VbrRegionId", vbrRegionId);
+}
+

smartag/src/model/CreateDedicatedLineBackupResult.cc

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

smartag/src/model/CreateSmartAccessGatewayRequest.cc

@@ -0,0 +1,302 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/CreateSmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::CreateSmartAccessGatewayRequest;
+
+CreateSmartAccessGatewayRequest::CreateSmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "CreateSmartAccessGateway")
+{}
+
+CreateSmartAccessGatewayRequest::~CreateSmartAccessGatewayRequest()
+{}
+
+int CreateSmartAccessGatewayRequest::getMaxBandWidth()const
+{
+	return maxBandWidth_;
+}
+
+void CreateSmartAccessGatewayRequest::setMaxBandWidth(int maxBandWidth)
+{
+	maxBandWidth_ = maxBandWidth;
+	setParameter("MaxBandWidth", std::to_string(maxBandWidth));
+}
+
+long CreateSmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateSmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateSmartAccessGatewayRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateSmartAccessGatewayRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverTown()const
+{
+	return receiverTown_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverTown(const std::string& receiverTown)
+{
+	receiverTown_ = receiverTown;
+	setParameter("ReceiverTown", receiverTown);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverDistrict()const
+{
+	return receiverDistrict_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverDistrict(const std::string& receiverDistrict)
+{
+	receiverDistrict_ = receiverDistrict;
+	setParameter("ReceiverDistrict", receiverDistrict);
+}
+
+std::string CreateSmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateSmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverAddress()const
+{
+	return receiverAddress_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverAddress(const std::string& receiverAddress)
+{
+	receiverAddress_ = receiverAddress;
+	setParameter("ReceiverAddress", receiverAddress);
+}
+
+std::string CreateSmartAccessGatewayRequest::getBuyerMessage()const
+{
+	return buyerMessage_;
+}
+
+void CreateSmartAccessGatewayRequest::setBuyerMessage(const std::string& buyerMessage)
+{
+	buyerMessage_ = buyerMessage;
+	setParameter("BuyerMessage", buyerMessage);
+}
+
+std::string CreateSmartAccessGatewayRequest::getHardWareSpec()const
+{
+	return hardWareSpec_;
+}
+
+void CreateSmartAccessGatewayRequest::setHardWareSpec(const std::string& hardWareSpec)
+{
+	hardWareSpec_ = hardWareSpec;
+	setParameter("HardWareSpec", hardWareSpec);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverEmail()const
+{
+	return receiverEmail_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverEmail(const std::string& receiverEmail)
+{
+	receiverEmail_ = receiverEmail;
+	setParameter("ReceiverEmail", receiverEmail);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverState()const
+{
+	return receiverState_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverState(const std::string& receiverState)
+{
+	receiverState_ = receiverState;
+	setParameter("ReceiverState", receiverState);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverCity()const
+{
+	return receiverCity_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverCity(const std::string& receiverCity)
+{
+	receiverCity_ = receiverCity;
+	setParameter("ReceiverCity", receiverCity);
+}
+
+int CreateSmartAccessGatewayRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateSmartAccessGatewayRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+bool CreateSmartAccessGatewayRequest::getAutoPay()const
+{
+	return autoPay_;
+}
+
+void CreateSmartAccessGatewayRequest::setAutoPay(bool autoPay)
+{
+	autoPay_ = autoPay;
+	setParameter("AutoPay", std::to_string(autoPay));
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverMobile()const
+{
+	return receiverMobile_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverMobile(const std::string& receiverMobile)
+{
+	receiverMobile_ = receiverMobile;
+	setParameter("ReceiverMobile", receiverMobile);
+}
+
+std::string CreateSmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateSmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateSmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateSmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateSmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateSmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverPhone()const
+{
+	return receiverPhone_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverPhone(const std::string& receiverPhone)
+{
+	receiverPhone_ = receiverPhone;
+	setParameter("ReceiverPhone", receiverPhone);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverName()const
+{
+	return receiverName_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverName(const std::string& receiverName)
+{
+	receiverName_ = receiverName;
+	setParameter("ReceiverName", receiverName);
+}
+
+std::string CreateSmartAccessGatewayRequest::getHaType()const
+{
+	return haType_;
+}
+
+void CreateSmartAccessGatewayRequest::setHaType(const std::string& haType)
+{
+	haType_ = haType;
+	setParameter("HaType", haType);
+}
+
+std::string CreateSmartAccessGatewayRequest::getName()const
+{
+	return name_;
+}
+
+void CreateSmartAccessGatewayRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverCountry()const
+{
+	return receiverCountry_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverCountry(const std::string& receiverCountry)
+{
+	receiverCountry_ = receiverCountry;
+	setParameter("ReceiverCountry", receiverCountry);
+}
+
+std::string CreateSmartAccessGatewayRequest::getChargeType()const
+{
+	return chargeType_;
+}
+
+void CreateSmartAccessGatewayRequest::setChargeType(const std::string& chargeType)
+{
+	chargeType_ = chargeType;
+	setParameter("ChargeType", chargeType);
+}
+
+std::string CreateSmartAccessGatewayRequest::getReceiverZip()const
+{
+	return receiverZip_;
+}
+
+void CreateSmartAccessGatewayRequest::setReceiverZip(const std::string& receiverZip)
+{
+	receiverZip_ = receiverZip;
+	setParameter("ReceiverZip", receiverZip);
+}
+

smartag/src/model/CreateSmartAccessGatewayResult.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/smartag/model/CreateSmartAccessGatewayResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Smartag;
+using namespace AlibabaCloud::Smartag::Model;
+
+CreateSmartAccessGatewayResult::CreateSmartAccessGatewayResult() :
+	ServiceResult()
+{}
+
+CreateSmartAccessGatewayResult::CreateSmartAccessGatewayResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateSmartAccessGatewayResult::~CreateSmartAccessGatewayResult()
+{}
+
+void CreateSmartAccessGatewayResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["SmartAGId"].isNull())
+		smartAGId_ = value["SmartAGId"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+
+}
+
+std::string CreateSmartAccessGatewayResult::getDescription()const
+{
+	return description_;
+}
+
+std::string CreateSmartAccessGatewayResult::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+std::string CreateSmartAccessGatewayResult::getOrderId()const
+{
+	return orderId_;
+}
+
+std::string CreateSmartAccessGatewayResult::getName()const
+{
+	return name_;
+}
+

smartag/src/model/DeleteCloudConnectNetworkRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DeleteCloudConnectNetworkRequest.h>
+
+using AlibabaCloud::Smartag::Model::DeleteCloudConnectNetworkRequest;
+
+DeleteCloudConnectNetworkRequest::DeleteCloudConnectNetworkRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DeleteCloudConnectNetwork")
+{}
+
+DeleteCloudConnectNetworkRequest::~DeleteCloudConnectNetworkRequest()
+{}
+
+long DeleteCloudConnectNetworkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteCloudConnectNetworkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteCloudConnectNetworkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteCloudConnectNetworkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteCloudConnectNetworkRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteCloudConnectNetworkRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteCloudConnectNetworkRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteCloudConnectNetworkRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DeleteCloudConnectNetworkRequest::getCcnId()const
+{
+	return ccnId_;
+}
+
+void DeleteCloudConnectNetworkRequest::setCcnId(const std::string& ccnId)
+{
+	ccnId_ = ccnId;
+	setParameter("CcnId", ccnId);
+}
+
+long DeleteCloudConnectNetworkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteCloudConnectNetworkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/DeleteCloudConnectNetworkResult.cc

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

smartag/src/model/DeleteDedicatedLineBackupRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DeleteDedicatedLineBackupRequest.h>
+
+using AlibabaCloud::Smartag::Model::DeleteDedicatedLineBackupRequest;
+
+DeleteDedicatedLineBackupRequest::DeleteDedicatedLineBackupRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DeleteDedicatedLineBackup")
+{}
+
+DeleteDedicatedLineBackupRequest::~DeleteDedicatedLineBackupRequest()
+{}
+
+long DeleteDedicatedLineBackupRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteDedicatedLineBackupRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDedicatedLineBackupRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteDedicatedLineBackupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteDedicatedLineBackupRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteDedicatedLineBackupRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteDedicatedLineBackupRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteDedicatedLineBackupRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DeleteDedicatedLineBackupRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void DeleteDedicatedLineBackupRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long DeleteDedicatedLineBackupRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteDedicatedLineBackupRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/DeleteDedicatedLineBackupResult.cc

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

smartag/src/model/DescribeCloudConnectNetworksRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DescribeCloudConnectNetworksRequest.h>
+
+using AlibabaCloud::Smartag::Model::DescribeCloudConnectNetworksRequest;
+
+DescribeCloudConnectNetworksRequest::DescribeCloudConnectNetworksRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DescribeCloudConnectNetworks")
+{}
+
+DescribeCloudConnectNetworksRequest::~DescribeCloudConnectNetworksRequest()
+{}
+
+long DescribeCloudConnectNetworksRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeCloudConnectNetworksRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeCloudConnectNetworksRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeCloudConnectNetworksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeCloudConnectNetworksRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeCloudConnectNetworksRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeCloudConnectNetworksRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeCloudConnectNetworksRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeCloudConnectNetworksRequest::getName()const
+{
+	return name_;
+}
+
+void DescribeCloudConnectNetworksRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string DescribeCloudConnectNetworksRequest::getCcnId()const
+{
+	return ccnId_;
+}
+
+void DescribeCloudConnectNetworksRequest::setCcnId(const std::string& ccnId)
+{
+	ccnId_ = ccnId;
+	setParameter("CcnId", ccnId);
+}
+
+std::string DescribeCloudConnectNetworksRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeCloudConnectNetworksRequest::setPageSize(const std::string& pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", pageSize);
+}
+
+long DescribeCloudConnectNetworksRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeCloudConnectNetworksRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeCloudConnectNetworksRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeCloudConnectNetworksRequest::setPageNumber(const std::string& pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", pageNumber);
+}
+

smartag/src/model/DescribeCloudConnectNetworksResult.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/smartag/model/DescribeCloudConnectNetworksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Smartag;
+using namespace AlibabaCloud::Smartag::Model;
+
+DescribeCloudConnectNetworksResult::DescribeCloudConnectNetworksResult() :
+	ServiceResult()
+{}
+
+DescribeCloudConnectNetworksResult::DescribeCloudConnectNetworksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCloudConnectNetworksResult::~DescribeCloudConnectNetworksResult()
+{}
+
+void DescribeCloudConnectNetworksResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allCloudConnectNetworks = value["CloudConnectNetworks"]["CloudConnectNetwork"];
+	for (auto value : allCloudConnectNetworks)
+	{
+		CloudConnectNetwork cloudConnectNetworksObject;
+		if(!value["CcnId"].isNull())
+			cloudConnectNetworksObject.ccnId = value["CcnId"].asString();
+		if(!value["Name"].isNull())
+			cloudConnectNetworksObject.name = value["Name"].asString();
+		if(!value["AssociatedCloudBoxCount"].isNull())
+			cloudConnectNetworksObject.associatedCloudBoxCount = value["AssociatedCloudBoxCount"].asString();
+		if(!value["AvailableCloudBoxCount"].isNull())
+			cloudConnectNetworksObject.availableCloudBoxCount = value["AvailableCloudBoxCount"].asString();
+		if(!value["AssociatedCenId"].isNull())
+			cloudConnectNetworksObject.associatedCenId = value["AssociatedCenId"].asString();
+		if(!value["AssociatedCenOwnerId"].isNull())
+			cloudConnectNetworksObject.associatedCenOwnerId = value["AssociatedCenOwnerId"].asString();
+		if(!value["Description"].isNull())
+			cloudConnectNetworksObject.description = value["Description"].asString();
+		if(!value["CreateTime"].isNull())
+			cloudConnectNetworksObject.createTime = std::stol(value["CreateTime"].asString());
+		if(!value["IsDefault"].isNull())
+			cloudConnectNetworksObject.isDefault = value["IsDefault"].asString() == "true";
+		cloudConnectNetworks_.push_back(cloudConnectNetworksObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+std::vector<DescribeCloudConnectNetworksResult::CloudConnectNetwork> DescribeCloudConnectNetworksResult::getCloudConnectNetworks()const
+{
+	return cloudConnectNetworks_;
+}
+
+int DescribeCloudConnectNetworksResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeCloudConnectNetworksResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeCloudConnectNetworksResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

smartag/src/model/DescribeRegionsRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/smartag/model/DescribeRegionsRequest.h>
+
+using AlibabaCloud::Smartag::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DescribeRegions")
+{}
+
+DescribeRegionsRequest::~DescribeRegionsRequest()
+{}
+
+long DescribeRegionsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeRegionsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeRegionsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeRegionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeRegionsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeRegionsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeRegionsRequest::getAcceptLanguage()const
+{
+	return acceptLanguage_;
+}
+
+void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
+{
+	acceptLanguage_ = acceptLanguage;
+	setParameter("AcceptLanguage", acceptLanguage);
+}
+
+long DescribeRegionsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeRegionsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/DescribeRegionsResult.cc

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

smartag/src/model/DescribeSmartAccessGatewayHaRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DescribeSmartAccessGatewayHaRequest.h>
+
+using AlibabaCloud::Smartag::Model::DescribeSmartAccessGatewayHaRequest;
+
+DescribeSmartAccessGatewayHaRequest::DescribeSmartAccessGatewayHaRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DescribeSmartAccessGatewayHa")
+{}
+
+DescribeSmartAccessGatewayHaRequest::~DescribeSmartAccessGatewayHaRequest()
+{}
+
+long DescribeSmartAccessGatewayHaRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeSmartAccessGatewayHaRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeSmartAccessGatewayHaRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeSmartAccessGatewayHaRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeSmartAccessGatewayHaRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeSmartAccessGatewayHaRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeSmartAccessGatewayHaRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeSmartAccessGatewayHaRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeSmartAccessGatewayHaRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void DescribeSmartAccessGatewayHaRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long DescribeSmartAccessGatewayHaRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeSmartAccessGatewayHaRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/DescribeSmartAccessGatewayHaResult.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DescribeSmartAccessGatewayHaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Smartag;
+using namespace AlibabaCloud::Smartag::Model;
+
+DescribeSmartAccessGatewayHaResult::DescribeSmartAccessGatewayHaResult() :
+	ServiceResult()
+{}
+
+DescribeSmartAccessGatewayHaResult::DescribeSmartAccessGatewayHaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSmartAccessGatewayHaResult::~DescribeSmartAccessGatewayHaResult()
+{}
+
+void DescribeSmartAccessGatewayHaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["DeviceLevelBackupState"].isNull())
+		deviceLevelBackupState_ = value["DeviceLevelBackupState"].asString();
+	if(!value["DeviceLevelBackupType"].isNull())
+		deviceLevelBackupType_ = value["DeviceLevelBackupType"].asString();
+	if(!value["MainDeviceId"].isNull())
+		mainDeviceId_ = value["MainDeviceId"].asString();
+	if(!value["BackupDeviceId"].isNull())
+		backupDeviceId_ = value["BackupDeviceId"].asString();
+	if(!value["LinkLevelBackupState"].isNull())
+		linkLevelBackupState_ = value["LinkLevelBackupState"].asString();
+	if(!value["LinkLevelBackupType"].isNull())
+		linkLevelBackupType_ = value["LinkLevelBackupType"].asString();
+	if(!value["MainLinkId"].isNull())
+		mainLinkId_ = value["MainLinkId"].asString();
+	if(!value["BackupLinkId"].isNull())
+		backupLinkId_ = value["BackupLinkId"].asString();
+	if(!value["SmartAGId"].isNull())
+		smartAGId_ = value["SmartAGId"].asString();
+
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getDeviceLevelBackupState()const
+{
+	return deviceLevelBackupState_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getBackupLinkId()const
+{
+	return backupLinkId_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getBackupDeviceId()const
+{
+	return backupDeviceId_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getLinkLevelBackupType()const
+{
+	return linkLevelBackupType_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getMainLinkId()const
+{
+	return mainLinkId_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getDeviceLevelBackupType()const
+{
+	return deviceLevelBackupType_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getLinkLevelBackupState()const
+{
+	return linkLevelBackupState_;
+}
+
+std::string DescribeSmartAccessGatewayHaResult::getMainDeviceId()const
+{
+	return mainDeviceId_;
+}
+

smartag/src/model/DescribeSmartAccessGatewayVersionsRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/smartag/model/DescribeSmartAccessGatewayVersionsRequest.h>
+
+using AlibabaCloud::Smartag::Model::DescribeSmartAccessGatewayVersionsRequest;
+
+DescribeSmartAccessGatewayVersionsRequest::DescribeSmartAccessGatewayVersionsRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DescribeSmartAccessGatewayVersions")
+{}
+
+DescribeSmartAccessGatewayVersionsRequest::~DescribeSmartAccessGatewayVersionsRequest()
+{}
+
+long DescribeSmartAccessGatewayVersionsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeSmartAccessGatewayVersionsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeSmartAccessGatewayVersionsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeSmartAccessGatewayVersionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeSmartAccessGatewayVersionsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeSmartAccessGatewayVersionsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeSmartAccessGatewayVersionsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeSmartAccessGatewayVersionsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeSmartAccessGatewayVersionsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeSmartAccessGatewayVersionsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/DescribeSmartAccessGatewayVersionsResult.cc

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

smartag/src/model/DescribeSmartAccessGatewaysRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DescribeSmartAccessGatewaysRequest.h>
+
+using AlibabaCloud::Smartag::Model::DescribeSmartAccessGatewaysRequest;
+
+DescribeSmartAccessGatewaysRequest::DescribeSmartAccessGatewaysRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "DescribeSmartAccessGateways")
+{}
+
+DescribeSmartAccessGatewaysRequest::~DescribeSmartAccessGatewaysRequest()
+{}
+
+long DescribeSmartAccessGatewaysRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getName()const
+{
+	return name_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setPageSize(const std::string& pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", pageSize);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getAssociatedCcnId()const
+{
+	return associatedCcnId_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setAssociatedCcnId(const std::string& associatedCcnId)
+{
+	associatedCcnId_ = associatedCcnId;
+	setParameter("AssociatedCcnId", associatedCcnId);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long DescribeSmartAccessGatewaysRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setPageNumber(const std::string& pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", pageNumber);
+}
+
+std::string DescribeSmartAccessGatewaysRequest::getStatus()const
+{
+	return status_;
+}
+
+void DescribeSmartAccessGatewaysRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

smartag/src/model/DescribeSmartAccessGatewaysResult.cc

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/DescribeSmartAccessGatewaysResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Smartag;
+using namespace AlibabaCloud::Smartag::Model;
+
+DescribeSmartAccessGatewaysResult::DescribeSmartAccessGatewaysResult() :
+	ServiceResult()
+{}
+
+DescribeSmartAccessGatewaysResult::DescribeSmartAccessGatewaysResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSmartAccessGatewaysResult::~DescribeSmartAccessGatewaysResult()
+{}
+
+void DescribeSmartAccessGatewaysResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allSmartAccessGateways = value["SmartAccessGateways"]["SmartAccessGateway"];
+	for (auto value : allSmartAccessGateways)
+	{
+		SmartAccessGateway smartAccessGatewaysObject;
+		if(!value["SmartAGId"].isNull())
+			smartAccessGatewaysObject.smartAGId = value["SmartAGId"].asString();
+		if(!value["Name"].isNull())
+			smartAccessGatewaysObject.name = value["Name"].asString();
+		if(!value["City"].isNull())
+			smartAccessGatewaysObject.city = value["City"].asString();
+		if(!value["MaxBandwidth"].isNull())
+			smartAccessGatewaysObject.maxBandwidth = value["MaxBandwidth"].asString();
+		if(!value["Status"].isNull())
+			smartAccessGatewaysObject.status = value["Status"].asString();
+		if(!value["CidrBlock"].isNull())
+			smartAccessGatewaysObject.cidrBlock = value["CidrBlock"].asString();
+		if(!value["AssociatedCcnId"].isNull())
+			smartAccessGatewaysObject.associatedCcnId = value["AssociatedCcnId"].asString();
+		if(!value["AssociatedCcnName"].isNull())
+			smartAccessGatewaysObject.associatedCcnName = value["AssociatedCcnName"].asString();
+		if(!value["Description"].isNull())
+			smartAccessGatewaysObject.description = value["Description"].asString();
+		if(!value["CreateTime"].isNull())
+			smartAccessGatewaysObject.createTime = std::stol(value["CreateTime"].asString());
+		if(!value["EndTime"].isNull())
+			smartAccessGatewaysObject.endTime = std::stol(value["EndTime"].asString());
+		if(!value["SoftwareVersion"].isNull())
+			smartAccessGatewaysObject.softwareVersion = value["SoftwareVersion"].asString();
+		if(!value["HardwareVersion"].isNull())
+			smartAccessGatewaysObject.hardwareVersion = value["HardwareVersion"].asString();
+		if(!value["SerialNumber"].isNull())
+			smartAccessGatewaysObject.serialNumber = value["SerialNumber"].asString();
+		if(!value["SecurityLockThreshold"].isNull())
+			smartAccessGatewaysObject.securityLockThreshold = std::stoi(value["SecurityLockThreshold"].asString());
+		smartAccessGateways_.push_back(smartAccessGatewaysObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeSmartAccessGatewaysResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeSmartAccessGatewaysResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeSmartAccessGatewaysResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeSmartAccessGatewaysResult::SmartAccessGateway> DescribeSmartAccessGatewaysResult::getSmartAccessGateways()const
+{
+	return smartAccessGateways_;
+}
+

smartag/src/model/GetCloudConnectNetworkUseLimitRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/smartag/model/GetCloudConnectNetworkUseLimitRequest.h>
+
+using AlibabaCloud::Smartag::Model::GetCloudConnectNetworkUseLimitRequest;
+
+GetCloudConnectNetworkUseLimitRequest::GetCloudConnectNetworkUseLimitRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "GetCloudConnectNetworkUseLimit")
+{}
+
+GetCloudConnectNetworkUseLimitRequest::~GetCloudConnectNetworkUseLimitRequest()
+{}
+
+long GetCloudConnectNetworkUseLimitRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void GetCloudConnectNetworkUseLimitRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string GetCloudConnectNetworkUseLimitRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void GetCloudConnectNetworkUseLimitRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string GetCloudConnectNetworkUseLimitRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetCloudConnectNetworkUseLimitRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetCloudConnectNetworkUseLimitRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void GetCloudConnectNetworkUseLimitRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long GetCloudConnectNetworkUseLimitRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void GetCloudConnectNetworkUseLimitRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/GetCloudConnectNetworkUseLimitResult.cc

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

smartag/src/model/GetSmartAccessGatewayUseLimitRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/smartag/model/GetSmartAccessGatewayUseLimitRequest.h>
+
+using AlibabaCloud::Smartag::Model::GetSmartAccessGatewayUseLimitRequest;
+
+GetSmartAccessGatewayUseLimitRequest::GetSmartAccessGatewayUseLimitRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "GetSmartAccessGatewayUseLimit")
+{}
+
+GetSmartAccessGatewayUseLimitRequest::~GetSmartAccessGatewayUseLimitRequest()
+{}
+
+long GetSmartAccessGatewayUseLimitRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void GetSmartAccessGatewayUseLimitRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string GetSmartAccessGatewayUseLimitRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void GetSmartAccessGatewayUseLimitRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string GetSmartAccessGatewayUseLimitRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetSmartAccessGatewayUseLimitRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetSmartAccessGatewayUseLimitRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void GetSmartAccessGatewayUseLimitRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long GetSmartAccessGatewayUseLimitRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void GetSmartAccessGatewayUseLimitRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/GetSmartAccessGatewayUseLimitResult.cc

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

smartag/src/model/ModifyCloudConnectNetworkRequest.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/ModifyCloudConnectNetworkRequest.h>
+
+using AlibabaCloud::Smartag::Model::ModifyCloudConnectNetworkRequest;
+
+ModifyCloudConnectNetworkRequest::ModifyCloudConnectNetworkRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "ModifyCloudConnectNetwork")
+{}
+
+ModifyCloudConnectNetworkRequest::~ModifyCloudConnectNetworkRequest()
+{}
+
+long ModifyCloudConnectNetworkRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyCloudConnectNetworkRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyCloudConnectNetworkRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyCloudConnectNetworkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyCloudConnectNetworkRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyCloudConnectNetworkRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ModifyCloudConnectNetworkRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyCloudConnectNetworkRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string ModifyCloudConnectNetworkRequest::getCcnId()const
+{
+	return ccnId_;
+}
+
+void ModifyCloudConnectNetworkRequest::setCcnId(const std::string& ccnId)
+{
+	ccnId_ = ccnId;
+	setParameter("CcnId", ccnId);
+}
+
+std::string ModifyCloudConnectNetworkRequest::getName()const
+{
+	return name_;
+}
+
+void ModifyCloudConnectNetworkRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string ModifyCloudConnectNetworkRequest::getDescription()const
+{
+	return description_;
+}
+
+void ModifyCloudConnectNetworkRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+long ModifyCloudConnectNetworkRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyCloudConnectNetworkRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/ModifyCloudConnectNetworkResult.cc

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

smartag/src/model/ModifySmartAccessGatewayRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/ModifySmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::ModifySmartAccessGatewayRequest;
+
+ModifySmartAccessGatewayRequest::ModifySmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "ModifySmartAccessGateway")
+{}
+
+ModifySmartAccessGatewayRequest::~ModifySmartAccessGatewayRequest()
+{}
+
+long ModifySmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifySmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifySmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifySmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifySmartAccessGatewayRequest::getCity()const
+{
+	return city_;
+}
+
+void ModifySmartAccessGatewayRequest::setCity(const std::string& city)
+{
+	city_ = city;
+	setParameter("City", city);
+}
+
+std::string ModifySmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifySmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ModifySmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifySmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string ModifySmartAccessGatewayRequest::getName()const
+{
+	return name_;
+}
+
+void ModifySmartAccessGatewayRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string ModifySmartAccessGatewayRequest::getCidrBlock()const
+{
+	return cidrBlock_;
+}
+
+void ModifySmartAccessGatewayRequest::setCidrBlock(const std::string& cidrBlock)
+{
+	cidrBlock_ = cidrBlock;
+	setParameter("CidrBlock", cidrBlock);
+}
+
+std::string ModifySmartAccessGatewayRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void ModifySmartAccessGatewayRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+std::string ModifySmartAccessGatewayRequest::getDescription()const
+{
+	return description_;
+}
+
+void ModifySmartAccessGatewayRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+long ModifySmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifySmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int ModifySmartAccessGatewayRequest::getSecurityLockThreshold()const
+{
+	return securityLockThreshold_;
+}
+
+void ModifySmartAccessGatewayRequest::setSecurityLockThreshold(int securityLockThreshold)
+{
+	securityLockThreshold_ = securityLockThreshold;
+	setParameter("SecurityLockThreshold", std::to_string(securityLockThreshold));
+}
+

smartag/src/model/ModifySmartAccessGatewayResult.cc

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

smartag/src/model/RebootSmartAccessGatewayRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/RebootSmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::RebootSmartAccessGatewayRequest;
+
+RebootSmartAccessGatewayRequest::RebootSmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "RebootSmartAccessGateway")
+{}
+
+RebootSmartAccessGatewayRequest::~RebootSmartAccessGatewayRequest()
+{}
+
+long RebootSmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void RebootSmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string RebootSmartAccessGatewayRequest::getSerialNumber()const
+{
+	return serialNumber_;
+}
+
+void RebootSmartAccessGatewayRequest::setSerialNumber(const std::string& serialNumber)
+{
+	serialNumber_ = serialNumber;
+	setParameter("SerialNumber", serialNumber);
+}
+
+std::string RebootSmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void RebootSmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string RebootSmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void RebootSmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string RebootSmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void RebootSmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string RebootSmartAccessGatewayRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void RebootSmartAccessGatewayRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long RebootSmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RebootSmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/RebootSmartAccessGatewayResult.cc

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

smartag/src/model/SwitchCloudBoxHaStateRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/SwitchCloudBoxHaStateRequest.h>
+
+using AlibabaCloud::Smartag::Model::SwitchCloudBoxHaStateRequest;
+
+SwitchCloudBoxHaStateRequest::SwitchCloudBoxHaStateRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "SwitchCloudBoxHaState")
+{}
+
+SwitchCloudBoxHaStateRequest::~SwitchCloudBoxHaStateRequest()
+{}
+
+long SwitchCloudBoxHaStateRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SwitchCloudBoxHaStateRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SwitchCloudBoxHaStateRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SwitchCloudBoxHaStateRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SwitchCloudBoxHaStateRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SwitchCloudBoxHaStateRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SwitchCloudBoxHaStateRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SwitchCloudBoxHaStateRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string SwitchCloudBoxHaStateRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void SwitchCloudBoxHaStateRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long SwitchCloudBoxHaStateRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SwitchCloudBoxHaStateRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/SwitchCloudBoxHaStateResult.cc

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

smartag/src/model/UnbindSmartAccessGatewayRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/UnbindSmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::UnbindSmartAccessGatewayRequest;
+
+UnbindSmartAccessGatewayRequest::UnbindSmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "UnbindSmartAccessGateway")
+{}
+
+UnbindSmartAccessGatewayRequest::~UnbindSmartAccessGatewayRequest()
+{}
+
+long UnbindSmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void UnbindSmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string UnbindSmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void UnbindSmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string UnbindSmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UnbindSmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string UnbindSmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void UnbindSmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string UnbindSmartAccessGatewayRequest::getCcnId()const
+{
+	return ccnId_;
+}
+
+void UnbindSmartAccessGatewayRequest::setCcnId(const std::string& ccnId)
+{
+	ccnId_ = ccnId;
+	setParameter("CcnId", ccnId);
+}
+
+std::string UnbindSmartAccessGatewayRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void UnbindSmartAccessGatewayRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long UnbindSmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void UnbindSmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/UnbindSmartAccessGatewayResult.cc

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

smartag/src/model/UnlockSmartAccessGatewayRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/UnlockSmartAccessGatewayRequest.h>
+
+using AlibabaCloud::Smartag::Model::UnlockSmartAccessGatewayRequest;
+
+UnlockSmartAccessGatewayRequest::UnlockSmartAccessGatewayRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "UnlockSmartAccessGateway")
+{}
+
+UnlockSmartAccessGatewayRequest::~UnlockSmartAccessGatewayRequest()
+{}
+
+long UnlockSmartAccessGatewayRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void UnlockSmartAccessGatewayRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string UnlockSmartAccessGatewayRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void UnlockSmartAccessGatewayRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string UnlockSmartAccessGatewayRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UnlockSmartAccessGatewayRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string UnlockSmartAccessGatewayRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void UnlockSmartAccessGatewayRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string UnlockSmartAccessGatewayRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void UnlockSmartAccessGatewayRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long UnlockSmartAccessGatewayRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void UnlockSmartAccessGatewayRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

smartag/src/model/UnlockSmartAccessGatewayResult.cc

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

smartag/src/model/UpdateSmartAccessGatewayVersionRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/smartag/model/UpdateSmartAccessGatewayVersionRequest.h>
+
+using AlibabaCloud::Smartag::Model::UpdateSmartAccessGatewayVersionRequest;
+
+UpdateSmartAccessGatewayVersionRequest::UpdateSmartAccessGatewayVersionRequest() :
+	RpcServiceRequest("smartag", "2018-03-13", "UpdateSmartAccessGatewayVersion")
+{}
+
+UpdateSmartAccessGatewayVersionRequest::~UpdateSmartAccessGatewayVersionRequest()
+{}
+
+long UpdateSmartAccessGatewayVersionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string UpdateSmartAccessGatewayVersionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string UpdateSmartAccessGatewayVersionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string UpdateSmartAccessGatewayVersionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string UpdateSmartAccessGatewayVersionRequest::getSmartAGId()const
+{
+	return smartAGId_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setSmartAGId(const std::string& smartAGId)
+{
+	smartAGId_ = smartAGId;
+	setParameter("SmartAGId", smartAGId);
+}
+
+long UpdateSmartAccessGatewayVersionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string UpdateSmartAccessGatewayVersionRequest::getVersionCode()const
+{
+	return versionCode_;
+}
+
+void UpdateSmartAccessGatewayVersionRequest::setVersionCode(const std::string& versionCode)
+{
+	versionCode_ = versionCode;
+	setParameter("VersionCode", versionCode);
+}
+

smartag/src/model/UpdateSmartAccessGatewayVersionResult.cc

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