Add new apis.

VERSION

@@ -1 +1 @@
-1.36.1473
+1.36.1474

swas-open/CMakeLists.txt

@@ -0,0 +1,258 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(swas-open_public_header 
+	include/alibabacloud/swas-open/SWAS_OPENClient.h
+	include/alibabacloud/swas-open/SWAS_OPENExport.h )
+
+set(swas-open_public_header_model 
+	include/alibabacloud/swas-open/model/AllocatePublicConnectionRequest.h
+	include/alibabacloud/swas-open/model/AllocatePublicConnectionResult.h
+	include/alibabacloud/swas-open/model/CreateCustomImageRequest.h
+	include/alibabacloud/swas-open/model/CreateCustomImageResult.h
+	include/alibabacloud/swas-open/model/CreateFirewallRuleRequest.h
+	include/alibabacloud/swas-open/model/CreateFirewallRuleResult.h
+	include/alibabacloud/swas-open/model/CreateInstancesRequest.h
+	include/alibabacloud/swas-open/model/CreateInstancesResult.h
+	include/alibabacloud/swas-open/model/CreateSnapshotRequest.h
+	include/alibabacloud/swas-open/model/CreateSnapshotResult.h
+	include/alibabacloud/swas-open/model/DeleteCustomImageRequest.h
+	include/alibabacloud/swas-open/model/DeleteCustomImageResult.h
+	include/alibabacloud/swas-open/model/DeleteFirewallRuleRequest.h
+	include/alibabacloud/swas-open/model/DeleteFirewallRuleResult.h
+	include/alibabacloud/swas-open/model/DeleteSnapshotRequest.h
+	include/alibabacloud/swas-open/model/DeleteSnapshotResult.h
+	include/alibabacloud/swas-open/model/DescribeCloudAssistantStatusRequest.h
+	include/alibabacloud/swas-open/model/DescribeCloudAssistantStatusResult.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseErrorLogsRequest.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseErrorLogsResult.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseInstanceMetricDataRequest.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseInstanceMetricDataResult.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseInstanceParametersRequest.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseInstanceParametersResult.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseInstancesRequest.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseInstancesResult.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseSlowLogRecordsRequest.h
+	include/alibabacloud/swas-open/model/DescribeDatabaseSlowLogRecordsResult.h
+	include/alibabacloud/swas-open/model/DescribeInvocationResultRequest.h
+	include/alibabacloud/swas-open/model/DescribeInvocationResultResult.h
+	include/alibabacloud/swas-open/model/DescribeInvocationsRequest.h
+	include/alibabacloud/swas-open/model/DescribeInvocationsResult.h
+	include/alibabacloud/swas-open/model/InstallCloudAssistantRequest.h
+	include/alibabacloud/swas-open/model/InstallCloudAssistantResult.h
+	include/alibabacloud/swas-open/model/ListDisksRequest.h
+	include/alibabacloud/swas-open/model/ListDisksResult.h
+	include/alibabacloud/swas-open/model/ListFirewallRulesRequest.h
+	include/alibabacloud/swas-open/model/ListFirewallRulesResult.h
+	include/alibabacloud/swas-open/model/ListImagesRequest.h
+	include/alibabacloud/swas-open/model/ListImagesResult.h
+	include/alibabacloud/swas-open/model/ListInstancePlansModificationRequest.h
+	include/alibabacloud/swas-open/model/ListInstancePlansModificationResult.h
+	include/alibabacloud/swas-open/model/ListInstancesRequest.h
+	include/alibabacloud/swas-open/model/ListInstancesResult.h
+	include/alibabacloud/swas-open/model/ListInstancesTrafficPackagesRequest.h
+	include/alibabacloud/swas-open/model/ListInstancesTrafficPackagesResult.h
+	include/alibabacloud/swas-open/model/ListPlansRequest.h
+	include/alibabacloud/swas-open/model/ListPlansResult.h
+	include/alibabacloud/swas-open/model/ListRegionsRequest.h
+	include/alibabacloud/swas-open/model/ListRegionsResult.h
+	include/alibabacloud/swas-open/model/ListSnapshotsRequest.h
+	include/alibabacloud/swas-open/model/ListSnapshotsResult.h
+	include/alibabacloud/swas-open/model/LoginInstanceRequest.h
+	include/alibabacloud/swas-open/model/LoginInstanceResult.h
+	include/alibabacloud/swas-open/model/ModifyDatabaseInstanceDescriptionRequest.h
+	include/alibabacloud/swas-open/model/ModifyDatabaseInstanceDescriptionResult.h
+	include/alibabacloud/swas-open/model/ModifyDatabaseInstanceParameterRequest.h
+	include/alibabacloud/swas-open/model/ModifyDatabaseInstanceParameterResult.h
+	include/alibabacloud/swas-open/model/ModifyImageShareStatusRequest.h
+	include/alibabacloud/swas-open/model/ModifyImageShareStatusResult.h
+	include/alibabacloud/swas-open/model/RebootInstanceRequest.h
+	include/alibabacloud/swas-open/model/RebootInstanceResult.h
+	include/alibabacloud/swas-open/model/ReleasePublicConnectionRequest.h
+	include/alibabacloud/swas-open/model/ReleasePublicConnectionResult.h
+	include/alibabacloud/swas-open/model/RenewInstanceRequest.h
+	include/alibabacloud/swas-open/model/RenewInstanceResult.h
+	include/alibabacloud/swas-open/model/ResetDatabaseAccountPasswordRequest.h
+	include/alibabacloud/swas-open/model/ResetDatabaseAccountPasswordResult.h
+	include/alibabacloud/swas-open/model/ResetDiskRequest.h
+	include/alibabacloud/swas-open/model/ResetDiskResult.h
+	include/alibabacloud/swas-open/model/ResetSystemRequest.h
+	include/alibabacloud/swas-open/model/ResetSystemResult.h
+	include/alibabacloud/swas-open/model/RestartDatabaseInstanceRequest.h
+	include/alibabacloud/swas-open/model/RestartDatabaseInstanceResult.h
+	include/alibabacloud/swas-open/model/RunCommandRequest.h
+	include/alibabacloud/swas-open/model/RunCommandResult.h
+	include/alibabacloud/swas-open/model/StartDatabaseInstanceRequest.h
+	include/alibabacloud/swas-open/model/StartDatabaseInstanceResult.h
+	include/alibabacloud/swas-open/model/StartInstanceRequest.h
+	include/alibabacloud/swas-open/model/StartInstanceResult.h
+	include/alibabacloud/swas-open/model/StopDatabaseInstanceRequest.h
+	include/alibabacloud/swas-open/model/StopDatabaseInstanceResult.h
+	include/alibabacloud/swas-open/model/StopInstanceRequest.h
+	include/alibabacloud/swas-open/model/StopInstanceResult.h
+	include/alibabacloud/swas-open/model/UpdateInstanceAttributeRequest.h
+	include/alibabacloud/swas-open/model/UpdateInstanceAttributeResult.h
+	include/alibabacloud/swas-open/model/UpgradeInstanceRequest.h
+	include/alibabacloud/swas-open/model/UpgradeInstanceResult.h )
+
+set(swas-open_src 
+	src/SWAS-OPENClient.cc
+	src/model/AllocatePublicConnectionRequest.cc
+	src/model/AllocatePublicConnectionResult.cc
+	src/model/CreateCustomImageRequest.cc
+	src/model/CreateCustomImageResult.cc
+	src/model/CreateFirewallRuleRequest.cc
+	src/model/CreateFirewallRuleResult.cc
+	src/model/CreateInstancesRequest.cc
+	src/model/CreateInstancesResult.cc
+	src/model/CreateSnapshotRequest.cc
+	src/model/CreateSnapshotResult.cc
+	src/model/DeleteCustomImageRequest.cc
+	src/model/DeleteCustomImageResult.cc
+	src/model/DeleteFirewallRuleRequest.cc
+	src/model/DeleteFirewallRuleResult.cc
+	src/model/DeleteSnapshotRequest.cc
+	src/model/DeleteSnapshotResult.cc
+	src/model/DescribeCloudAssistantStatusRequest.cc
+	src/model/DescribeCloudAssistantStatusResult.cc
+	src/model/DescribeDatabaseErrorLogsRequest.cc
+	src/model/DescribeDatabaseErrorLogsResult.cc
+	src/model/DescribeDatabaseInstanceMetricDataRequest.cc
+	src/model/DescribeDatabaseInstanceMetricDataResult.cc
+	src/model/DescribeDatabaseInstanceParametersRequest.cc
+	src/model/DescribeDatabaseInstanceParametersResult.cc
+	src/model/DescribeDatabaseInstancesRequest.cc
+	src/model/DescribeDatabaseInstancesResult.cc
+	src/model/DescribeDatabaseSlowLogRecordsRequest.cc
+	src/model/DescribeDatabaseSlowLogRecordsResult.cc
+	src/model/DescribeInvocationResultRequest.cc
+	src/model/DescribeInvocationResultResult.cc
+	src/model/DescribeInvocationsRequest.cc
+	src/model/DescribeInvocationsResult.cc
+	src/model/InstallCloudAssistantRequest.cc
+	src/model/InstallCloudAssistantResult.cc
+	src/model/ListDisksRequest.cc
+	src/model/ListDisksResult.cc
+	src/model/ListFirewallRulesRequest.cc
+	src/model/ListFirewallRulesResult.cc
+	src/model/ListImagesRequest.cc
+	src/model/ListImagesResult.cc
+	src/model/ListInstancePlansModificationRequest.cc
+	src/model/ListInstancePlansModificationResult.cc
+	src/model/ListInstancesRequest.cc
+	src/model/ListInstancesResult.cc
+	src/model/ListInstancesTrafficPackagesRequest.cc
+	src/model/ListInstancesTrafficPackagesResult.cc
+	src/model/ListPlansRequest.cc
+	src/model/ListPlansResult.cc
+	src/model/ListRegionsRequest.cc
+	src/model/ListRegionsResult.cc
+	src/model/ListSnapshotsRequest.cc
+	src/model/ListSnapshotsResult.cc
+	src/model/LoginInstanceRequest.cc
+	src/model/LoginInstanceResult.cc
+	src/model/ModifyDatabaseInstanceDescriptionRequest.cc
+	src/model/ModifyDatabaseInstanceDescriptionResult.cc
+	src/model/ModifyDatabaseInstanceParameterRequest.cc
+	src/model/ModifyDatabaseInstanceParameterResult.cc
+	src/model/ModifyImageShareStatusRequest.cc
+	src/model/ModifyImageShareStatusResult.cc
+	src/model/RebootInstanceRequest.cc
+	src/model/RebootInstanceResult.cc
+	src/model/ReleasePublicConnectionRequest.cc
+	src/model/ReleasePublicConnectionResult.cc
+	src/model/RenewInstanceRequest.cc
+	src/model/RenewInstanceResult.cc
+	src/model/ResetDatabaseAccountPasswordRequest.cc
+	src/model/ResetDatabaseAccountPasswordResult.cc
+	src/model/ResetDiskRequest.cc
+	src/model/ResetDiskResult.cc
+	src/model/ResetSystemRequest.cc
+	src/model/ResetSystemResult.cc
+	src/model/RestartDatabaseInstanceRequest.cc
+	src/model/RestartDatabaseInstanceResult.cc
+	src/model/RunCommandRequest.cc
+	src/model/RunCommandResult.cc
+	src/model/StartDatabaseInstanceRequest.cc
+	src/model/StartDatabaseInstanceResult.cc
+	src/model/StartInstanceRequest.cc
+	src/model/StartInstanceResult.cc
+	src/model/StopDatabaseInstanceRequest.cc
+	src/model/StopDatabaseInstanceResult.cc
+	src/model/StopInstanceRequest.cc
+	src/model/StopInstanceResult.cc
+	src/model/UpdateInstanceAttributeRequest.cc
+	src/model/UpdateInstanceAttributeResult.cc
+	src/model/UpgradeInstanceRequest.cc
+	src/model/UpgradeInstanceResult.cc )
+
+add_library(swas-open ${LIB_TYPE}
+	${swas-open_public_header}
+	${swas-open_public_header_model}
+	${swas-open_src})
+
+set_target_properties(swas-open
+	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}swas-open
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(swas-open
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_SWAS_OPEN_LIBRARY)
+endif()
+
+target_include_directories(swas-open
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(swas-open
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(swas-open
+		jsoncpp)
+	target_include_directories(swas-open
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(swas-open
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(swas-open
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(swas-open
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(swas-open
+		jsoncpp)
+endif()
+
+install(FILES ${swas-open_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/swas-open)
+install(FILES ${swas-open_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/swas-open/model)
+install(TARGETS swas-open
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

swas-open/include/alibabacloud/swas-open/SWAS_OPENClient.h

@@ -0,0 +1,398 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SWAS_OPEN_SWAS_OPENCLIENT_H_
+#define ALIBABACLOUD_SWAS_OPEN_SWAS_OPENCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "SWAS_OPENExport.h"
+#include "model/AllocatePublicConnectionRequest.h"
+#include "model/AllocatePublicConnectionResult.h"
+#include "model/CreateCustomImageRequest.h"
+#include "model/CreateCustomImageResult.h"
+#include "model/CreateFirewallRuleRequest.h"
+#include "model/CreateFirewallRuleResult.h"
+#include "model/CreateInstancesRequest.h"
+#include "model/CreateInstancesResult.h"
+#include "model/CreateSnapshotRequest.h"
+#include "model/CreateSnapshotResult.h"
+#include "model/DeleteCustomImageRequest.h"
+#include "model/DeleteCustomImageResult.h"
+#include "model/DeleteFirewallRuleRequest.h"
+#include "model/DeleteFirewallRuleResult.h"
+#include "model/DeleteSnapshotRequest.h"
+#include "model/DeleteSnapshotResult.h"
+#include "model/DescribeCloudAssistantStatusRequest.h"
+#include "model/DescribeCloudAssistantStatusResult.h"
+#include "model/DescribeDatabaseErrorLogsRequest.h"
+#include "model/DescribeDatabaseErrorLogsResult.h"
+#include "model/DescribeDatabaseInstanceMetricDataRequest.h"
+#include "model/DescribeDatabaseInstanceMetricDataResult.h"
+#include "model/DescribeDatabaseInstanceParametersRequest.h"
+#include "model/DescribeDatabaseInstanceParametersResult.h"
+#include "model/DescribeDatabaseInstancesRequest.h"
+#include "model/DescribeDatabaseInstancesResult.h"
+#include "model/DescribeDatabaseSlowLogRecordsRequest.h"
+#include "model/DescribeDatabaseSlowLogRecordsResult.h"
+#include "model/DescribeInvocationResultRequest.h"
+#include "model/DescribeInvocationResultResult.h"
+#include "model/DescribeInvocationsRequest.h"
+#include "model/DescribeInvocationsResult.h"
+#include "model/InstallCloudAssistantRequest.h"
+#include "model/InstallCloudAssistantResult.h"
+#include "model/ListDisksRequest.h"
+#include "model/ListDisksResult.h"
+#include "model/ListFirewallRulesRequest.h"
+#include "model/ListFirewallRulesResult.h"
+#include "model/ListImagesRequest.h"
+#include "model/ListImagesResult.h"
+#include "model/ListInstancePlansModificationRequest.h"
+#include "model/ListInstancePlansModificationResult.h"
+#include "model/ListInstancesRequest.h"
+#include "model/ListInstancesResult.h"
+#include "model/ListInstancesTrafficPackagesRequest.h"
+#include "model/ListInstancesTrafficPackagesResult.h"
+#include "model/ListPlansRequest.h"
+#include "model/ListPlansResult.h"
+#include "model/ListRegionsRequest.h"
+#include "model/ListRegionsResult.h"
+#include "model/ListSnapshotsRequest.h"
+#include "model/ListSnapshotsResult.h"
+#include "model/LoginInstanceRequest.h"
+#include "model/LoginInstanceResult.h"
+#include "model/ModifyDatabaseInstanceDescriptionRequest.h"
+#include "model/ModifyDatabaseInstanceDescriptionResult.h"
+#include "model/ModifyDatabaseInstanceParameterRequest.h"
+#include "model/ModifyDatabaseInstanceParameterResult.h"
+#include "model/ModifyImageShareStatusRequest.h"
+#include "model/ModifyImageShareStatusResult.h"
+#include "model/RebootInstanceRequest.h"
+#include "model/RebootInstanceResult.h"
+#include "model/ReleasePublicConnectionRequest.h"
+#include "model/ReleasePublicConnectionResult.h"
+#include "model/RenewInstanceRequest.h"
+#include "model/RenewInstanceResult.h"
+#include "model/ResetDatabaseAccountPasswordRequest.h"
+#include "model/ResetDatabaseAccountPasswordResult.h"
+#include "model/ResetDiskRequest.h"
+#include "model/ResetDiskResult.h"
+#include "model/ResetSystemRequest.h"
+#include "model/ResetSystemResult.h"
+#include "model/RestartDatabaseInstanceRequest.h"
+#include "model/RestartDatabaseInstanceResult.h"
+#include "model/RunCommandRequest.h"
+#include "model/RunCommandResult.h"
+#include "model/StartDatabaseInstanceRequest.h"
+#include "model/StartDatabaseInstanceResult.h"
+#include "model/StartInstanceRequest.h"
+#include "model/StartInstanceResult.h"
+#include "model/StopDatabaseInstanceRequest.h"
+#include "model/StopDatabaseInstanceResult.h"
+#include "model/StopInstanceRequest.h"
+#include "model/StopInstanceResult.h"
+#include "model/UpdateInstanceAttributeRequest.h"
+#include "model/UpdateInstanceAttributeResult.h"
+#include "model/UpgradeInstanceRequest.h"
+#include "model/UpgradeInstanceResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		class ALIBABACLOUD_SWAS_OPEN_EXPORT SWAS_OPENClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AllocatePublicConnectionResult> AllocatePublicConnectionOutcome;
+			typedef std::future<AllocatePublicConnectionOutcome> AllocatePublicConnectionOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::AllocatePublicConnectionRequest&, const AllocatePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocatePublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::CreateCustomImageResult> CreateCustomImageOutcome;
+			typedef std::future<CreateCustomImageOutcome> CreateCustomImageOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::CreateCustomImageRequest&, const CreateCustomImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCustomImageAsyncHandler;
+			typedef Outcome<Error, Model::CreateFirewallRuleResult> CreateFirewallRuleOutcome;
+			typedef std::future<CreateFirewallRuleOutcome> CreateFirewallRuleOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::CreateFirewallRuleRequest&, const CreateFirewallRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateFirewallRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateInstancesResult> CreateInstancesOutcome;
+			typedef std::future<CreateInstancesOutcome> CreateInstancesOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::CreateInstancesRequest&, const CreateInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInstancesAsyncHandler;
+			typedef Outcome<Error, Model::CreateSnapshotResult> CreateSnapshotOutcome;
+			typedef std::future<CreateSnapshotOutcome> CreateSnapshotOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::CreateSnapshotRequest&, const CreateSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSnapshotAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCustomImageResult> DeleteCustomImageOutcome;
+			typedef std::future<DeleteCustomImageOutcome> DeleteCustomImageOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DeleteCustomImageRequest&, const DeleteCustomImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCustomImageAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFirewallRuleResult> DeleteFirewallRuleOutcome;
+			typedef std::future<DeleteFirewallRuleOutcome> DeleteFirewallRuleOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DeleteFirewallRuleRequest&, const DeleteFirewallRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFirewallRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSnapshotResult> DeleteSnapshotOutcome;
+			typedef std::future<DeleteSnapshotOutcome> DeleteSnapshotOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DeleteSnapshotRequest&, const DeleteSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSnapshotAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCloudAssistantStatusResult> DescribeCloudAssistantStatusOutcome;
+			typedef std::future<DescribeCloudAssistantStatusOutcome> DescribeCloudAssistantStatusOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeCloudAssistantStatusRequest&, const DescribeCloudAssistantStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCloudAssistantStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDatabaseErrorLogsResult> DescribeDatabaseErrorLogsOutcome;
+			typedef std::future<DescribeDatabaseErrorLogsOutcome> DescribeDatabaseErrorLogsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeDatabaseErrorLogsRequest&, const DescribeDatabaseErrorLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabaseErrorLogsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDatabaseInstanceMetricDataResult> DescribeDatabaseInstanceMetricDataOutcome;
+			typedef std::future<DescribeDatabaseInstanceMetricDataOutcome> DescribeDatabaseInstanceMetricDataOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeDatabaseInstanceMetricDataRequest&, const DescribeDatabaseInstanceMetricDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabaseInstanceMetricDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDatabaseInstanceParametersResult> DescribeDatabaseInstanceParametersOutcome;
+			typedef std::future<DescribeDatabaseInstanceParametersOutcome> DescribeDatabaseInstanceParametersOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeDatabaseInstanceParametersRequest&, const DescribeDatabaseInstanceParametersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabaseInstanceParametersAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDatabaseInstancesResult> DescribeDatabaseInstancesOutcome;
+			typedef std::future<DescribeDatabaseInstancesOutcome> DescribeDatabaseInstancesOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeDatabaseInstancesRequest&, const DescribeDatabaseInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabaseInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDatabaseSlowLogRecordsResult> DescribeDatabaseSlowLogRecordsOutcome;
+			typedef std::future<DescribeDatabaseSlowLogRecordsOutcome> DescribeDatabaseSlowLogRecordsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeDatabaseSlowLogRecordsRequest&, const DescribeDatabaseSlowLogRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabaseSlowLogRecordsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeInvocationResultResult> DescribeInvocationResultOutcome;
+			typedef std::future<DescribeInvocationResultOutcome> DescribeInvocationResultOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeInvocationResultRequest&, const DescribeInvocationResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInvocationResultAsyncHandler;
+			typedef Outcome<Error, Model::DescribeInvocationsResult> DescribeInvocationsOutcome;
+			typedef std::future<DescribeInvocationsOutcome> DescribeInvocationsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeInvocationsRequest&, const DescribeInvocationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInvocationsAsyncHandler;
+			typedef Outcome<Error, Model::InstallCloudAssistantResult> InstallCloudAssistantOutcome;
+			typedef std::future<InstallCloudAssistantOutcome> InstallCloudAssistantOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::InstallCloudAssistantRequest&, const InstallCloudAssistantOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InstallCloudAssistantAsyncHandler;
+			typedef Outcome<Error, Model::ListDisksResult> ListDisksOutcome;
+			typedef std::future<ListDisksOutcome> ListDisksOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListDisksRequest&, const ListDisksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDisksAsyncHandler;
+			typedef Outcome<Error, Model::ListFirewallRulesResult> ListFirewallRulesOutcome;
+			typedef std::future<ListFirewallRulesOutcome> ListFirewallRulesOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListFirewallRulesRequest&, const ListFirewallRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFirewallRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListImagesResult> ListImagesOutcome;
+			typedef std::future<ListImagesOutcome> ListImagesOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListImagesRequest&, const ListImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListImagesAsyncHandler;
+			typedef Outcome<Error, Model::ListInstancePlansModificationResult> ListInstancePlansModificationOutcome;
+			typedef std::future<ListInstancePlansModificationOutcome> ListInstancePlansModificationOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListInstancePlansModificationRequest&, const ListInstancePlansModificationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancePlansModificationAsyncHandler;
+			typedef Outcome<Error, Model::ListInstancesResult> ListInstancesOutcome;
+			typedef std::future<ListInstancesOutcome> ListInstancesOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListInstancesRequest&, const ListInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesAsyncHandler;
+			typedef Outcome<Error, Model::ListInstancesTrafficPackagesResult> ListInstancesTrafficPackagesOutcome;
+			typedef std::future<ListInstancesTrafficPackagesOutcome> ListInstancesTrafficPackagesOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListInstancesTrafficPackagesRequest&, const ListInstancesTrafficPackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesTrafficPackagesAsyncHandler;
+			typedef Outcome<Error, Model::ListPlansResult> ListPlansOutcome;
+			typedef std::future<ListPlansOutcome> ListPlansOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListPlansRequest&, const ListPlansOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPlansAsyncHandler;
+			typedef Outcome<Error, Model::ListRegionsResult> ListRegionsOutcome;
+			typedef std::future<ListRegionsOutcome> ListRegionsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListRegionsRequest&, const ListRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRegionsAsyncHandler;
+			typedef Outcome<Error, Model::ListSnapshotsResult> ListSnapshotsOutcome;
+			typedef std::future<ListSnapshotsOutcome> ListSnapshotsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListSnapshotsRequest&, const ListSnapshotsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSnapshotsAsyncHandler;
+			typedef Outcome<Error, Model::LoginInstanceResult> LoginInstanceOutcome;
+			typedef std::future<LoginInstanceOutcome> LoginInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::LoginInstanceRequest&, const LoginInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LoginInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDatabaseInstanceDescriptionResult> ModifyDatabaseInstanceDescriptionOutcome;
+			typedef std::future<ModifyDatabaseInstanceDescriptionOutcome> ModifyDatabaseInstanceDescriptionOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ModifyDatabaseInstanceDescriptionRequest&, const ModifyDatabaseInstanceDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDatabaseInstanceDescriptionAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDatabaseInstanceParameterResult> ModifyDatabaseInstanceParameterOutcome;
+			typedef std::future<ModifyDatabaseInstanceParameterOutcome> ModifyDatabaseInstanceParameterOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ModifyDatabaseInstanceParameterRequest&, const ModifyDatabaseInstanceParameterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDatabaseInstanceParameterAsyncHandler;
+			typedef Outcome<Error, Model::ModifyImageShareStatusResult> ModifyImageShareStatusOutcome;
+			typedef std::future<ModifyImageShareStatusOutcome> ModifyImageShareStatusOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ModifyImageShareStatusRequest&, const ModifyImageShareStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyImageShareStatusAsyncHandler;
+			typedef Outcome<Error, Model::RebootInstanceResult> RebootInstanceOutcome;
+			typedef std::future<RebootInstanceOutcome> RebootInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::RebootInstanceRequest&, const RebootInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebootInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ReleasePublicConnectionResult> ReleasePublicConnectionOutcome;
+			typedef std::future<ReleasePublicConnectionOutcome> ReleasePublicConnectionOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ReleasePublicConnectionRequest&, const ReleasePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleasePublicConnectionAsyncHandler;
+			typedef Outcome<Error, Model::RenewInstanceResult> RenewInstanceOutcome;
+			typedef std::future<RenewInstanceOutcome> RenewInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::RenewInstanceRequest&, const RenewInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenewInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ResetDatabaseAccountPasswordResult> ResetDatabaseAccountPasswordOutcome;
+			typedef std::future<ResetDatabaseAccountPasswordOutcome> ResetDatabaseAccountPasswordOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ResetDatabaseAccountPasswordRequest&, const ResetDatabaseAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetDatabaseAccountPasswordAsyncHandler;
+			typedef Outcome<Error, Model::ResetDiskResult> ResetDiskOutcome;
+			typedef std::future<ResetDiskOutcome> ResetDiskOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ResetDiskRequest&, const ResetDiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetDiskAsyncHandler;
+			typedef Outcome<Error, Model::ResetSystemResult> ResetSystemOutcome;
+			typedef std::future<ResetSystemOutcome> ResetSystemOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ResetSystemRequest&, const ResetSystemOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetSystemAsyncHandler;
+			typedef Outcome<Error, Model::RestartDatabaseInstanceResult> RestartDatabaseInstanceOutcome;
+			typedef std::future<RestartDatabaseInstanceOutcome> RestartDatabaseInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::RestartDatabaseInstanceRequest&, const RestartDatabaseInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartDatabaseInstanceAsyncHandler;
+			typedef Outcome<Error, Model::RunCommandResult> RunCommandOutcome;
+			typedef std::future<RunCommandOutcome> RunCommandOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::RunCommandRequest&, const RunCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunCommandAsyncHandler;
+			typedef Outcome<Error, Model::StartDatabaseInstanceResult> StartDatabaseInstanceOutcome;
+			typedef std::future<StartDatabaseInstanceOutcome> StartDatabaseInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::StartDatabaseInstanceRequest&, const StartDatabaseInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDatabaseInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StartInstanceResult> StartInstanceOutcome;
+			typedef std::future<StartInstanceOutcome> StartInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::StartInstanceRequest&, const StartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StopDatabaseInstanceResult> StopDatabaseInstanceOutcome;
+			typedef std::future<StopDatabaseInstanceOutcome> StopDatabaseInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::StopDatabaseInstanceRequest&, const StopDatabaseInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDatabaseInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
+			typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateInstanceAttributeResult> UpdateInstanceAttributeOutcome;
+			typedef std::future<UpdateInstanceAttributeOutcome> UpdateInstanceAttributeOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::UpdateInstanceAttributeRequest&, const UpdateInstanceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateInstanceAttributeAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeInstanceResult> UpgradeInstanceOutcome;
+			typedef std::future<UpgradeInstanceOutcome> UpgradeInstanceOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::UpgradeInstanceRequest&, const UpgradeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeInstanceAsyncHandler;
+
+			SWAS_OPENClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			SWAS_OPENClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			SWAS_OPENClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~SWAS_OPENClient();
+			AllocatePublicConnectionOutcome allocatePublicConnection(const Model::AllocatePublicConnectionRequest &request)const;
+			void allocatePublicConnectionAsync(const Model::AllocatePublicConnectionRequest& request, const AllocatePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AllocatePublicConnectionOutcomeCallable allocatePublicConnectionCallable(const Model::AllocatePublicConnectionRequest& request) const;
+			CreateCustomImageOutcome createCustomImage(const Model::CreateCustomImageRequest &request)const;
+			void createCustomImageAsync(const Model::CreateCustomImageRequest& request, const CreateCustomImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCustomImageOutcomeCallable createCustomImageCallable(const Model::CreateCustomImageRequest& request) const;
+			CreateFirewallRuleOutcome createFirewallRule(const Model::CreateFirewallRuleRequest &request)const;
+			void createFirewallRuleAsync(const Model::CreateFirewallRuleRequest& request, const CreateFirewallRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateFirewallRuleOutcomeCallable createFirewallRuleCallable(const Model::CreateFirewallRuleRequest& request) const;
+			CreateInstancesOutcome createInstances(const Model::CreateInstancesRequest &request)const;
+			void createInstancesAsync(const Model::CreateInstancesRequest& request, const CreateInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateInstancesOutcomeCallable createInstancesCallable(const Model::CreateInstancesRequest& request) const;
+			CreateSnapshotOutcome createSnapshot(const Model::CreateSnapshotRequest &request)const;
+			void createSnapshotAsync(const Model::CreateSnapshotRequest& request, const CreateSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSnapshotOutcomeCallable createSnapshotCallable(const Model::CreateSnapshotRequest& request) const;
+			DeleteCustomImageOutcome deleteCustomImage(const Model::DeleteCustomImageRequest &request)const;
+			void deleteCustomImageAsync(const Model::DeleteCustomImageRequest& request, const DeleteCustomImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCustomImageOutcomeCallable deleteCustomImageCallable(const Model::DeleteCustomImageRequest& request) const;
+			DeleteFirewallRuleOutcome deleteFirewallRule(const Model::DeleteFirewallRuleRequest &request)const;
+			void deleteFirewallRuleAsync(const Model::DeleteFirewallRuleRequest& request, const DeleteFirewallRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFirewallRuleOutcomeCallable deleteFirewallRuleCallable(const Model::DeleteFirewallRuleRequest& request) const;
+			DeleteSnapshotOutcome deleteSnapshot(const Model::DeleteSnapshotRequest &request)const;
+			void deleteSnapshotAsync(const Model::DeleteSnapshotRequest& request, const DeleteSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSnapshotOutcomeCallable deleteSnapshotCallable(const Model::DeleteSnapshotRequest& request) const;
+			DescribeCloudAssistantStatusOutcome describeCloudAssistantStatus(const Model::DescribeCloudAssistantStatusRequest &request)const;
+			void describeCloudAssistantStatusAsync(const Model::DescribeCloudAssistantStatusRequest& request, const DescribeCloudAssistantStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCloudAssistantStatusOutcomeCallable describeCloudAssistantStatusCallable(const Model::DescribeCloudAssistantStatusRequest& request) const;
+			DescribeDatabaseErrorLogsOutcome describeDatabaseErrorLogs(const Model::DescribeDatabaseErrorLogsRequest &request)const;
+			void describeDatabaseErrorLogsAsync(const Model::DescribeDatabaseErrorLogsRequest& request, const DescribeDatabaseErrorLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDatabaseErrorLogsOutcomeCallable describeDatabaseErrorLogsCallable(const Model::DescribeDatabaseErrorLogsRequest& request) const;
+			DescribeDatabaseInstanceMetricDataOutcome describeDatabaseInstanceMetricData(const Model::DescribeDatabaseInstanceMetricDataRequest &request)const;
+			void describeDatabaseInstanceMetricDataAsync(const Model::DescribeDatabaseInstanceMetricDataRequest& request, const DescribeDatabaseInstanceMetricDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDatabaseInstanceMetricDataOutcomeCallable describeDatabaseInstanceMetricDataCallable(const Model::DescribeDatabaseInstanceMetricDataRequest& request) const;
+			DescribeDatabaseInstanceParametersOutcome describeDatabaseInstanceParameters(const Model::DescribeDatabaseInstanceParametersRequest &request)const;
+			void describeDatabaseInstanceParametersAsync(const Model::DescribeDatabaseInstanceParametersRequest& request, const DescribeDatabaseInstanceParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDatabaseInstanceParametersOutcomeCallable describeDatabaseInstanceParametersCallable(const Model::DescribeDatabaseInstanceParametersRequest& request) const;
+			DescribeDatabaseInstancesOutcome describeDatabaseInstances(const Model::DescribeDatabaseInstancesRequest &request)const;
+			void describeDatabaseInstancesAsync(const Model::DescribeDatabaseInstancesRequest& request, const DescribeDatabaseInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDatabaseInstancesOutcomeCallable describeDatabaseInstancesCallable(const Model::DescribeDatabaseInstancesRequest& request) const;
+			DescribeDatabaseSlowLogRecordsOutcome describeDatabaseSlowLogRecords(const Model::DescribeDatabaseSlowLogRecordsRequest &request)const;
+			void describeDatabaseSlowLogRecordsAsync(const Model::DescribeDatabaseSlowLogRecordsRequest& request, const DescribeDatabaseSlowLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDatabaseSlowLogRecordsOutcomeCallable describeDatabaseSlowLogRecordsCallable(const Model::DescribeDatabaseSlowLogRecordsRequest& request) const;
+			DescribeInvocationResultOutcome describeInvocationResult(const Model::DescribeInvocationResultRequest &request)const;
+			void describeInvocationResultAsync(const Model::DescribeInvocationResultRequest& request, const DescribeInvocationResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInvocationResultOutcomeCallable describeInvocationResultCallable(const Model::DescribeInvocationResultRequest& request) const;
+			DescribeInvocationsOutcome describeInvocations(const Model::DescribeInvocationsRequest &request)const;
+			void describeInvocationsAsync(const Model::DescribeInvocationsRequest& request, const DescribeInvocationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeInvocationsOutcomeCallable describeInvocationsCallable(const Model::DescribeInvocationsRequest& request) const;
+			InstallCloudAssistantOutcome installCloudAssistant(const Model::InstallCloudAssistantRequest &request)const;
+			void installCloudAssistantAsync(const Model::InstallCloudAssistantRequest& request, const InstallCloudAssistantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InstallCloudAssistantOutcomeCallable installCloudAssistantCallable(const Model::InstallCloudAssistantRequest& request) const;
+			ListDisksOutcome listDisks(const Model::ListDisksRequest &request)const;
+			void listDisksAsync(const Model::ListDisksRequest& request, const ListDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDisksOutcomeCallable listDisksCallable(const Model::ListDisksRequest& request) const;
+			ListFirewallRulesOutcome listFirewallRules(const Model::ListFirewallRulesRequest &request)const;
+			void listFirewallRulesAsync(const Model::ListFirewallRulesRequest& request, const ListFirewallRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFirewallRulesOutcomeCallable listFirewallRulesCallable(const Model::ListFirewallRulesRequest& request) const;
+			ListImagesOutcome listImages(const Model::ListImagesRequest &request)const;
+			void listImagesAsync(const Model::ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListImagesOutcomeCallable listImagesCallable(const Model::ListImagesRequest& request) const;
+			ListInstancePlansModificationOutcome listInstancePlansModification(const Model::ListInstancePlansModificationRequest &request)const;
+			void listInstancePlansModificationAsync(const Model::ListInstancePlansModificationRequest& request, const ListInstancePlansModificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstancePlansModificationOutcomeCallable listInstancePlansModificationCallable(const Model::ListInstancePlansModificationRequest& request) const;
+			ListInstancesOutcome listInstances(const Model::ListInstancesRequest &request)const;
+			void listInstancesAsync(const Model::ListInstancesRequest& request, const ListInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstancesOutcomeCallable listInstancesCallable(const Model::ListInstancesRequest& request) const;
+			ListInstancesTrafficPackagesOutcome listInstancesTrafficPackages(const Model::ListInstancesTrafficPackagesRequest &request)const;
+			void listInstancesTrafficPackagesAsync(const Model::ListInstancesTrafficPackagesRequest& request, const ListInstancesTrafficPackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstancesTrafficPackagesOutcomeCallable listInstancesTrafficPackagesCallable(const Model::ListInstancesTrafficPackagesRequest& request) const;
+			ListPlansOutcome listPlans(const Model::ListPlansRequest &request)const;
+			void listPlansAsync(const Model::ListPlansRequest& request, const ListPlansAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPlansOutcomeCallable listPlansCallable(const Model::ListPlansRequest& request) const;
+			ListRegionsOutcome listRegions(const Model::ListRegionsRequest &request)const;
+			void listRegionsAsync(const Model::ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListRegionsOutcomeCallable listRegionsCallable(const Model::ListRegionsRequest& request) const;
+			ListSnapshotsOutcome listSnapshots(const Model::ListSnapshotsRequest &request)const;
+			void listSnapshotsAsync(const Model::ListSnapshotsRequest& request, const ListSnapshotsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSnapshotsOutcomeCallable listSnapshotsCallable(const Model::ListSnapshotsRequest& request) const;
+			LoginInstanceOutcome loginInstance(const Model::LoginInstanceRequest &request)const;
+			void loginInstanceAsync(const Model::LoginInstanceRequest& request, const LoginInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			LoginInstanceOutcomeCallable loginInstanceCallable(const Model::LoginInstanceRequest& request) const;
+			ModifyDatabaseInstanceDescriptionOutcome modifyDatabaseInstanceDescription(const Model::ModifyDatabaseInstanceDescriptionRequest &request)const;
+			void modifyDatabaseInstanceDescriptionAsync(const Model::ModifyDatabaseInstanceDescriptionRequest& request, const ModifyDatabaseInstanceDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDatabaseInstanceDescriptionOutcomeCallable modifyDatabaseInstanceDescriptionCallable(const Model::ModifyDatabaseInstanceDescriptionRequest& request) const;
+			ModifyDatabaseInstanceParameterOutcome modifyDatabaseInstanceParameter(const Model::ModifyDatabaseInstanceParameterRequest &request)const;
+			void modifyDatabaseInstanceParameterAsync(const Model::ModifyDatabaseInstanceParameterRequest& request, const ModifyDatabaseInstanceParameterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDatabaseInstanceParameterOutcomeCallable modifyDatabaseInstanceParameterCallable(const Model::ModifyDatabaseInstanceParameterRequest& request) const;
+			ModifyImageShareStatusOutcome modifyImageShareStatus(const Model::ModifyImageShareStatusRequest &request)const;
+			void modifyImageShareStatusAsync(const Model::ModifyImageShareStatusRequest& request, const ModifyImageShareStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyImageShareStatusOutcomeCallable modifyImageShareStatusCallable(const Model::ModifyImageShareStatusRequest& request) const;
+			RebootInstanceOutcome rebootInstance(const Model::RebootInstanceRequest &request)const;
+			void rebootInstanceAsync(const Model::RebootInstanceRequest& request, const RebootInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RebootInstanceOutcomeCallable rebootInstanceCallable(const Model::RebootInstanceRequest& request) const;
+			ReleasePublicConnectionOutcome releasePublicConnection(const Model::ReleasePublicConnectionRequest &request)const;
+			void releasePublicConnectionAsync(const Model::ReleasePublicConnectionRequest& request, const ReleasePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleasePublicConnectionOutcomeCallable releasePublicConnectionCallable(const Model::ReleasePublicConnectionRequest& request) const;
+			RenewInstanceOutcome renewInstance(const Model::RenewInstanceRequest &request)const;
+			void renewInstanceAsync(const Model::RenewInstanceRequest& request, const RenewInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RenewInstanceOutcomeCallable renewInstanceCallable(const Model::RenewInstanceRequest& request) const;
+			ResetDatabaseAccountPasswordOutcome resetDatabaseAccountPassword(const Model::ResetDatabaseAccountPasswordRequest &request)const;
+			void resetDatabaseAccountPasswordAsync(const Model::ResetDatabaseAccountPasswordRequest& request, const ResetDatabaseAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResetDatabaseAccountPasswordOutcomeCallable resetDatabaseAccountPasswordCallable(const Model::ResetDatabaseAccountPasswordRequest& request) const;
+			ResetDiskOutcome resetDisk(const Model::ResetDiskRequest &request)const;
+			void resetDiskAsync(const Model::ResetDiskRequest& request, const ResetDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResetDiskOutcomeCallable resetDiskCallable(const Model::ResetDiskRequest& request) const;
+			ResetSystemOutcome resetSystem(const Model::ResetSystemRequest &request)const;
+			void resetSystemAsync(const Model::ResetSystemRequest& request, const ResetSystemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResetSystemOutcomeCallable resetSystemCallable(const Model::ResetSystemRequest& request) const;
+			RestartDatabaseInstanceOutcome restartDatabaseInstance(const Model::RestartDatabaseInstanceRequest &request)const;
+			void restartDatabaseInstanceAsync(const Model::RestartDatabaseInstanceRequest& request, const RestartDatabaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestartDatabaseInstanceOutcomeCallable restartDatabaseInstanceCallable(const Model::RestartDatabaseInstanceRequest& request) const;
+			RunCommandOutcome runCommand(const Model::RunCommandRequest &request)const;
+			void runCommandAsync(const Model::RunCommandRequest& request, const RunCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunCommandOutcomeCallable runCommandCallable(const Model::RunCommandRequest& request) const;
+			StartDatabaseInstanceOutcome startDatabaseInstance(const Model::StartDatabaseInstanceRequest &request)const;
+			void startDatabaseInstanceAsync(const Model::StartDatabaseInstanceRequest& request, const StartDatabaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartDatabaseInstanceOutcomeCallable startDatabaseInstanceCallable(const Model::StartDatabaseInstanceRequest& request) const;
+			StartInstanceOutcome startInstance(const Model::StartInstanceRequest &request)const;
+			void startInstanceAsync(const Model::StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartInstanceOutcomeCallable startInstanceCallable(const Model::StartInstanceRequest& request) const;
+			StopDatabaseInstanceOutcome stopDatabaseInstance(const Model::StopDatabaseInstanceRequest &request)const;
+			void stopDatabaseInstanceAsync(const Model::StopDatabaseInstanceRequest& request, const StopDatabaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopDatabaseInstanceOutcomeCallable stopDatabaseInstanceCallable(const Model::StopDatabaseInstanceRequest& request) const;
+			StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
+			void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;
+			UpdateInstanceAttributeOutcome updateInstanceAttribute(const Model::UpdateInstanceAttributeRequest &request)const;
+			void updateInstanceAttributeAsync(const Model::UpdateInstanceAttributeRequest& request, const UpdateInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateInstanceAttributeOutcomeCallable updateInstanceAttributeCallable(const Model::UpdateInstanceAttributeRequest& request) const;
+			UpgradeInstanceOutcome upgradeInstance(const Model::UpgradeInstanceRequest &request)const;
+			void upgradeInstanceAsync(const Model::UpgradeInstanceRequest& request, const UpgradeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpgradeInstanceOutcomeCallable upgradeInstanceCallable(const Model::UpgradeInstanceRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_SWAS_OPEN_SWAS_OPENCLIENT_H_

swas-open/include/alibabacloud/swas-open/SWAS_OPENExport.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_SWAS_OPEN_SWAS_OPENEXPORT_H_
+#define ALIBABACLOUD_SWAS_OPEN_SWAS_OPENEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_SWAS_OPEN_LIBRARY)
+#		define ALIBABACLOUD_SWAS_OPEN_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_SWAS_OPEN_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_SWAS_OPEN_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_SWAS_OPEN_SWAS_OPENEXPORT_H_

swas-open/include/alibabacloud/swas-open/model/AllocatePublicConnectionRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_ALLOCATEPUBLICCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_ALLOCATEPUBLICCONNECTIONREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT AllocatePublicConnectionRequest : public RpcServiceRequest {
+public:
+	AllocatePublicConnectionRequest();
+	~AllocatePublicConnectionRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_ALLOCATEPUBLICCONNECTIONREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/AllocatePublicConnectionResult.h

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

swas-open/include/alibabacloud/swas-open/model/CreateCustomImageRequest.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_SWAS_OPEN_MODEL_CREATECUSTOMIMAGEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_CREATECUSTOMIMAGEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT CreateCustomImageRequest : public RpcServiceRequest {
+public:
+	CreateCustomImageRequest();
+	~CreateCustomImageRequest();
+	std::string getSystemSnapshotId() const;
+	void setSystemSnapshotId(const std::string &systemSnapshotId);
+	std::string getDataSnapshotId() const;
+	void setDataSnapshotId(const std::string &dataSnapshotId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getImageName() const;
+	void setImageName(const std::string &imageName);
+
+private:
+	std::string systemSnapshotId_;
+	std::string dataSnapshotId_;
+	std::string clientToken_;
+	std::string description_;
+	std::string instanceId_;
+	std::string regionId_;
+	std::string imageName_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_CREATECUSTOMIMAGEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/CreateCustomImageResult.h

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

swas-open/include/alibabacloud/swas-open/model/CreateFirewallRuleRequest.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_SWAS_OPEN_MODEL_CREATEFIREWALLRULEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEFIREWALLRULEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT CreateFirewallRuleRequest : public RpcServiceRequest {
+public:
+	CreateFirewallRuleRequest();
+	~CreateFirewallRuleRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRemark() const;
+	void setRemark(const std::string &remark);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRuleProtocol() const;
+	void setRuleProtocol(const std::string &ruleProtocol);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPort() const;
+	void setPort(const std::string &port);
+
+private:
+	std::string clientToken_;
+	std::string remark_;
+	std::string instanceId_;
+	std::string ruleProtocol_;
+	std::string regionId_;
+	std::string port_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEFIREWALLRULEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/CreateFirewallRuleResult.h

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

swas-open/include/alibabacloud/swas-open/model/CreateInstancesRequest.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_SWAS_OPEN_MODEL_CREATEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEINSTANCESREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT CreateInstancesRequest : public RpcServiceRequest {
+public:
+	CreateInstancesRequest();
+	~CreateInstancesRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getAutoRenewPeriod() const;
+	void setAutoRenewPeriod(int autoRenewPeriod);
+	int getPeriod() const;
+	void setPeriod(int period);
+	int getAmount() const;
+	void setAmount(int amount);
+	bool getAutoRenew() const;
+	void setAutoRenew(bool autoRenew);
+	long getDataDiskSize() const;
+	void setDataDiskSize(long dataDiskSize);
+	std::string getPlanId() const;
+	void setPlanId(const std::string &planId);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+
+private:
+	std::string imageId_;
+	std::string clientToken_;
+	std::string regionId_;
+	int autoRenewPeriod_;
+	int period_;
+	int amount_;
+	bool autoRenew_;
+	long dataDiskSize_;
+	std::string planId_;
+	std::string chargeType_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEINSTANCESREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/CreateInstancesResult.h

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

swas-open/include/alibabacloud/swas-open/model/CreateSnapshotRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_CREATESNAPSHOTREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_CREATESNAPSHOTREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT CreateSnapshotRequest : public RpcServiceRequest {
+public:
+	CreateSnapshotRequest();
+	~CreateSnapshotRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getSnapshotName() const;
+	void setSnapshotName(const std::string &snapshotName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDiskId() const;
+	void setDiskId(const std::string &diskId);
+
+private:
+	std::string clientToken_;
+	std::string snapshotName_;
+	std::string regionId_;
+	std::string diskId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_CREATESNAPSHOTREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/CreateSnapshotResult.h

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

swas-open/include/alibabacloud/swas-open/model/DeleteCustomImageRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DELETECUSTOMIMAGEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETECUSTOMIMAGEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DeleteCustomImageRequest : public RpcServiceRequest {
+public:
+	DeleteCustomImageRequest();
+	~DeleteCustomImageRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string imageId_;
+	std::string clientToken_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETECUSTOMIMAGEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DeleteCustomImageResult.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_SWAS_OPEN_MODEL_DELETECUSTOMIMAGERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETECUSTOMIMAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DeleteCustomImageResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteCustomImageResult();
+				explicit DeleteCustomImageResult(const std::string &payload);
+				~DeleteCustomImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETECUSTOMIMAGERESULT_H_

swas-open/include/alibabacloud/swas-open/model/DeleteFirewallRuleRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEFIREWALLRULEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEFIREWALLRULEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DeleteFirewallRuleRequest : public RpcServiceRequest {
+public:
+	DeleteFirewallRuleRequest();
+	~DeleteFirewallRuleRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getRuleId() const;
+	void setRuleId(const std::string &ruleId);
+
+private:
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+	std::string ruleId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEFIREWALLRULEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DeleteFirewallRuleResult.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_SWAS_OPEN_MODEL_DELETEFIREWALLRULERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEFIREWALLRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DeleteFirewallRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteFirewallRuleResult();
+				explicit DeleteFirewallRuleResult(const std::string &payload);
+				~DeleteFirewallRuleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEFIREWALLRULERESULT_H_

swas-open/include/alibabacloud/swas-open/model/DeleteSnapshotRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DELETESNAPSHOTREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETESNAPSHOTREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DeleteSnapshotRequest : public RpcServiceRequest {
+public:
+	DeleteSnapshotRequest();
+	~DeleteSnapshotRequest();
+	std::string getSnapshotId() const;
+	void setSnapshotId(const std::string &snapshotId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string snapshotId_;
+	std::string clientToken_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETESNAPSHOTREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DeleteSnapshotResult.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_SWAS_OPEN_MODEL_DELETESNAPSHOTRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETESNAPSHOTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DeleteSnapshotResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSnapshotResult();
+				explicit DeleteSnapshotResult(const std::string &payload);
+				~DeleteSnapshotResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETESNAPSHOTRESULT_H_

swas-open/include/alibabacloud/swas-open/model/DescribeCloudAssistantStatusRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBECLOUDASSISTANTSTATUSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBECLOUDASSISTANTSTATUSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeCloudAssistantStatusRequest : public RpcServiceRequest {
+public:
+	DescribeCloudAssistantStatusRequest();
+	~DescribeCloudAssistantStatusRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	int pageNumber_;
+	std::string regionId_;
+	std::vector<std::string> instanceIds_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBECLOUDASSISTANTSTATUSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeCloudAssistantStatusResult.h

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

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseErrorLogsRequest.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_SWAS_OPEN_MODEL_DESCRIBEDATABASEERRORLOGSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEERRORLOGSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseErrorLogsRequest : public RpcServiceRequest {
+public:
+	DescribeDatabaseErrorLogsRequest();
+	~DescribeDatabaseErrorLogsRequest();
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	std::string databaseInstanceId_;
+	std::string endTime_;
+	std::string startTime_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEERRORLOGSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseErrorLogsResult.h

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

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseInstanceMetricDataRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEMETRICDATAREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEMETRICDATAREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseInstanceMetricDataRequest : public RpcServiceRequest {
+public:
+	DescribeDatabaseInstanceMetricDataRequest();
+	~DescribeDatabaseInstanceMetricDataRequest();
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getMetricName() const;
+	void setMetricName(const std::string &metricName);
+
+private:
+	std::string databaseInstanceId_;
+	std::string endTime_;
+	std::string startTime_;
+	std::string regionId_;
+	std::string metricName_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEMETRICDATAREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseInstanceMetricDataResult.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_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEMETRICDATARESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEMETRICDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseInstanceMetricDataResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDatabaseInstanceMetricDataResult();
+				explicit DescribeDatabaseInstanceMetricDataResult(const std::string &payload);
+				~DescribeDatabaseInstanceMetricDataResult();
+				std::string getMetricName()const;
+				std::string getDataFormat()const;
+				std::string getUnit()const;
+				std::string getMetricData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string metricName_;
+				std::string dataFormat_;
+				std::string unit_;
+				std::string metricData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEMETRICDATARESULT_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseInstanceParametersRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEPARAMETERSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEPARAMETERSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseInstanceParametersRequest : public RpcServiceRequest {
+public:
+	DescribeDatabaseInstanceParametersRequest();
+	~DescribeDatabaseInstanceParametersRequest();
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string databaseInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEPARAMETERSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseInstanceParametersResult.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_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEPARAMETERSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEPARAMETERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseInstanceParametersResult : public ServiceResult
+			{
+			public:
+				struct ConfigParameter
+				{
+					std::string forceModify;
+					std::string checkingCode;
+					std::string parameterValue;
+					std::string forceRestart;
+					std::string parameterName;
+					std::string parameterDescription;
+				};
+				struct RunningParameter
+				{
+					std::string forceModify;
+					std::string checkingCode;
+					std::string parameterValue;
+					std::string forceRestart;
+					std::string parameterName;
+					std::string parameterDescription;
+				};
+
+
+				DescribeDatabaseInstanceParametersResult();
+				explicit DescribeDatabaseInstanceParametersResult(const std::string &payload);
+				~DescribeDatabaseInstanceParametersResult();
+				std::vector<RunningParameter> getRunningParameters()const;
+				std::string getEngineVersion()const;
+				std::vector<ConfigParameter> getConfigParameters()const;
+				std::string getEngine()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<RunningParameter> runningParameters_;
+				std::string engineVersion_;
+				std::vector<ConfigParameter> configParameters_;
+				std::string engine_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCEPARAMETERSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseInstancesRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCESREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseInstancesRequest : public RpcServiceRequest {
+public:
+	DescribeDatabaseInstancesRequest();
+	~DescribeDatabaseInstancesRequest();
+	std::string getDatabaseInstanceIds() const;
+	void setDatabaseInstanceIds(const std::string &databaseInstanceIds);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	std::string databaseInstanceIds_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCESREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseInstancesResult.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCESRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseInstancesResult : public ServiceResult
+			{
+			public:
+				struct DatabaseInstance
+				{
+					std::string memory;
+					std::string databaseInstanceId;
+					std::string publicConnection;
+					std::string cpu;
+					std::string databaseInstanceEdition;
+					std::string businessStatus;
+					std::string superAccountName;
+					int storage;
+					std::string chargeType;
+					std::string expiredTime;
+					std::string creationTime;
+					std::string privateConnection;
+					std::string databaseInstanceName;
+					std::string regionId;
+					std::string databaseVersion;
+					std::string databaseInstanceStatus;
+				};
+
+
+				DescribeDatabaseInstancesResult();
+				explicit DescribeDatabaseInstancesResult(const std::string &payload);
+				~DescribeDatabaseInstancesResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<DatabaseInstance> getDatabaseInstances()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<DatabaseInstance> databaseInstances_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASEINSTANCESRESULT_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseSlowLogRecordsRequest.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_SWAS_OPEN_MODEL_DESCRIBEDATABASESLOWLOGRECORDSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASESLOWLOGRECORDSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseSlowLogRecordsRequest : public RpcServiceRequest {
+public:
+	DescribeDatabaseSlowLogRecordsRequest();
+	~DescribeDatabaseSlowLogRecordsRequest();
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	std::string databaseInstanceId_;
+	std::string endTime_;
+	std::string startTime_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASESLOWLOGRECORDSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeDatabaseSlowLogRecordsResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASESLOWLOGRECORDSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASESLOWLOGRECORDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeDatabaseSlowLogRecordsResult : public ServiceResult
+			{
+			public:
+				struct SlowLog
+				{
+					long queryTimes;
+					std::string executionStartTime;
+					long returnRowCounts;
+					long lockTimes;
+					std::string dBName;
+					long parseRowCounts;
+					std::string hostAddress;
+					long queryTimeMS;
+					std::string sQLText;
+				};
+
+
+				DescribeDatabaseSlowLogRecordsResult();
+				explicit DescribeDatabaseSlowLogRecordsResult(const std::string &payload);
+				~DescribeDatabaseSlowLogRecordsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				long getPhysicalIORead()const;
+				std::vector<SlowLog> getSlowLogs()const;
+				std::string getEngine()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				long physicalIORead_;
+				std::vector<SlowLog> slowLogs_;
+				std::string engine_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEDATABASESLOWLOGRECORDSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/DescribeInvocationResultRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONRESULTREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONRESULTREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeInvocationResultRequest : public RpcServiceRequest {
+public:
+	DescribeInvocationResultRequest();
+	~DescribeInvocationResultRequest();
+	std::string getInvokeId() const;
+	void setInvokeId(const std::string &invokeId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string invokeId_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONRESULTREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeInvocationResultResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONRESULTRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONRESULTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeInvocationResultResult : public ServiceResult
+			{
+			public:
+				struct InvocationResult
+				{
+					std::string invocationStatus;
+					std::string instanceId;
+					std::string invokeUser;
+					long exitCode;
+					std::string errorInfo;
+					std::string output;
+					std::string startTime;
+					std::string errorCode;
+					std::string invokeRecordStatus;
+					std::string finishedTime;
+					std::string invokeId;
+				};
+
+
+				DescribeInvocationResultResult();
+				explicit DescribeInvocationResultResult(const std::string &payload);
+				~DescribeInvocationResultResult();
+				InvocationResult getInvocationResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				InvocationResult invocationResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONRESULTRESULT_H_

swas-open/include/alibabacloud/swas-open/model/DescribeInvocationsRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeInvocationsRequest : public RpcServiceRequest {
+public:
+	DescribeInvocationsRequest();
+	~DescribeInvocationsRequest();
+	std::string getInvokeStatus() const;
+	void setInvokeStatus(const std::string &invokeStatus);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	std::string invokeStatus_;
+	int pageNumber_;
+	std::string instanceId_;
+	std::string regionId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DescribeInvocationsResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT DescribeInvocationsResult : public ServiceResult
+			{
+			public:
+				struct Invocation
+				{
+					std::string commandContent;
+					std::string invocationStatus;
+					std::string parameters;
+					std::string invokeStatus;
+					std::string commandType;
+					std::string creationTime;
+					std::string commandName;
+					std::string invokeId;
+				};
+
+
+				DescribeInvocationsResult();
+				explicit DescribeInvocationsResult(const std::string &payload);
+				~DescribeInvocationsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				std::vector<Invocation> getInvocations()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				std::vector<Invocation> invocations_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DESCRIBEINVOCATIONSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/InstallCloudAssistantRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_INSTALLCLOUDASSISTANTREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_INSTALLCLOUDASSISTANTREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT InstallCloudAssistantRequest : public RpcServiceRequest {
+public:
+	InstallCloudAssistantRequest();
+	~InstallCloudAssistantRequest();
+	std::string getSite() const;
+	void setSite(const std::string &site);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+
+private:
+	std::string site_;
+	std::string regionId_;
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_INSTALLCLOUDASSISTANTREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/InstallCloudAssistantResult.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_SWAS_OPEN_MODEL_INSTALLCLOUDASSISTANTRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_INSTALLCLOUDASSISTANTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT InstallCloudAssistantResult : public ServiceResult
+			{
+			public:
+
+
+				InstallCloudAssistantResult();
+				explicit InstallCloudAssistantResult(const std::string &payload);
+				~InstallCloudAssistantResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_INSTALLCLOUDASSISTANTRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListDisksRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTDISKSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTDISKSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListDisksRequest : public RpcServiceRequest {
+public:
+	ListDisksRequest();
+	~ListDisksRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getDiskIds() const;
+	void setDiskIds(const std::string &diskIds);
+
+private:
+	int pageNumber_;
+	std::string instanceId_;
+	std::string regionId_;
+	int pageSize_;
+	std::string diskIds_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTDISKSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListDisksResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SWAS_OPEN_MODEL_LISTDISKSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTDISKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListDisksResult : public ServiceResult
+			{
+			public:
+				struct Disk
+				{
+					std::string status;
+					std::string diskType;
+					std::string category;
+					std::string instanceId;
+					std::string device;
+					int size;
+					std::string creationTime;
+					std::string diskChargeType;
+					std::string regionId;
+					std::string diskName;
+					std::string diskId;
+				};
+
+
+				ListDisksResult();
+				explicit ListDisksResult(const std::string &payload);
+				~ListDisksResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Disk> getDisks()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Disk> disks_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTDISKSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListFirewallRulesRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTFIREWALLRULESREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTFIREWALLRULESREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListFirewallRulesRequest : public RpcServiceRequest {
+public:
+	ListFirewallRulesRequest();
+	~ListFirewallRulesRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	int pageNumber_;
+	std::string instanceId_;
+	std::string regionId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTFIREWALLRULESREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListFirewallRulesResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTFIREWALLRULESRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTFIREWALLRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListFirewallRulesResult : public ServiceResult
+			{
+			public:
+				struct FirewallRule
+				{
+					std::string port;
+					std::string ruleId;
+					std::string ruleProtocol;
+					std::string remark;
+				};
+
+
+				ListFirewallRulesResult();
+				explicit ListFirewallRulesResult(const std::string &payload);
+				~ListFirewallRulesResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<FirewallRule> getFirewallRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<FirewallRule> firewallRules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTFIREWALLRULESRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListImagesRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTIMAGESREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTIMAGESREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListImagesRequest : public RpcServiceRequest {
+public:
+	ListImagesRequest();
+	~ListImagesRequest();
+	std::string getImageType() const;
+	void setImageType(const std::string &imageType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getImageIds() const;
+	void setImageIds(const std::string &imageIds);
+
+private:
+	std::string imageType_;
+	std::string regionId_;
+	std::string imageIds_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTIMAGESREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListImagesResult.h

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

swas-open/include/alibabacloud/swas-open/model/ListInstancePlansModificationRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCEPLANSMODIFICATIONREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCEPLANSMODIFICATIONREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListInstancePlansModificationRequest : public RpcServiceRequest {
+public:
+	ListInstancePlansModificationRequest();
+	~ListInstancePlansModificationRequest();
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCEPLANSMODIFICATIONREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListInstancePlansModificationResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCEPLANSMODIFICATIONRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCEPLANSMODIFICATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListInstancePlansModificationResult : public ServiceResult
+			{
+			public:
+				struct Plan
+				{
+					std::string diskType;
+					double originPrice;
+					std::string supportPlatform;
+					int memory;
+					int bandwidth;
+					std::string planId;
+					std::string currency;
+					int diskSize;
+					int core;
+					int flow;
+				};
+
+
+				ListInstancePlansModificationResult();
+				explicit ListInstancePlansModificationResult(const std::string &payload);
+				~ListInstancePlansModificationResult();
+				std::vector<Plan> getPlans()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Plan> plans_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCEPLANSMODIFICATIONRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListInstancesRequest.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_SWAS_OPEN_MODEL_LISTINSTANCESREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListInstancesRequest : public RpcServiceRequest {
+public:
+	ListInstancesRequest();
+	~ListInstancesRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getInstanceIds() const;
+	void setInstanceIds(const std::string &instanceIds);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getPublicIpAddresses() const;
+	void setPublicIpAddresses(const std::string &publicIpAddresses);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+
+private:
+	int pageNumber_;
+	std::string regionId_;
+	std::string instanceIds_;
+	int pageSize_;
+	std::string publicIpAddresses_;
+	std::string chargeType_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListInstancesResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListInstancesResult : public ServiceResult
+			{
+			public:
+				struct Instance
+				{
+					std::string status;
+					std::string instanceId;
+					std::string planId;
+					std::string ddosStatus;
+					std::string businessStatus;
+					std::string publicIpAddress;
+					std::string instanceName;
+					std::string innerIpAddress;
+					std::string chargeType;
+					std::string expiredTime;
+					std::string creationTime;
+					std::string imageId;
+					std::string regionId;
+				};
+
+
+				ListInstancesResult();
+				explicit ListInstancesResult(const std::string &payload);
+				~ListInstancesResult();
+				std::vector<Instance> getInstances()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Instance> instances_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListInstancesTrafficPackagesRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESTRAFFICPACKAGESREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESTRAFFICPACKAGESREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListInstancesTrafficPackagesRequest : public RpcServiceRequest {
+public:
+	ListInstancesTrafficPackagesRequest();
+	~ListInstancesTrafficPackagesRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getInstanceIds() const;
+	void setInstanceIds(const std::string &instanceIds);
+
+private:
+	std::string regionId_;
+	std::string instanceIds_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTINSTANCESTRAFFICPACKAGESREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListInstancesTrafficPackagesResult.h

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

swas-open/include/alibabacloud/swas-open/model/ListPlansRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SWAS_OPEN_MODEL_LISTPLANSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTPLANSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListPlansRequest : public RpcServiceRequest {
+public:
+	ListPlansRequest();
+	~ListPlansRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTPLANSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListPlansResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LISTPLANSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTPLANSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListPlansResult : public ServiceResult
+			{
+			public:
+				struct Plan
+				{
+					std::string diskType;
+					double originPrice;
+					std::string supportPlatform;
+					int memory;
+					int bandwidth;
+					std::string planId;
+					std::string currency;
+					int diskSize;
+					int core;
+					int flow;
+				};
+
+
+				ListPlansResult();
+				explicit ListPlansResult(const std::string &payload);
+				~ListPlansResult();
+				std::vector<Plan> getPlans()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Plan> plans_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTPLANSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListRegionsRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_SWAS_OPEN_MODEL_LISTREGIONSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTREGIONSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListRegionsRequest : public RpcServiceRequest {
+public:
+	ListRegionsRequest();
+	~ListRegionsRequest();
+
+private:
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTREGIONSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListRegionsResult.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_SWAS_OPEN_MODEL_LISTREGIONSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListRegionsResult : public ServiceResult
+			{
+			public:
+				struct Region
+				{
+					std::string regionId;
+					std::string regionEndpoint;
+					std::string localName;
+				};
+
+
+				ListRegionsResult();
+				explicit ListRegionsResult(const std::string &payload);
+				~ListRegionsResult();
+				std::vector<Region> getRegions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Region> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTREGIONSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ListSnapshotsRequest.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_SWAS_OPEN_MODEL_LISTSNAPSHOTSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTSNAPSHOTSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ListSnapshotsRequest : public RpcServiceRequest {
+public:
+	ListSnapshotsRequest();
+	~ListSnapshotsRequest();
+	std::string getSnapshotIds() const;
+	void setSnapshotIds(const std::string &snapshotIds);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getDiskId() const;
+	void setDiskId(const std::string &diskId);
+
+private:
+	std::string snapshotIds_;
+	int pageNumber_;
+	std::string instanceId_;
+	std::string regionId_;
+	int pageSize_;
+	std::string diskId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTSNAPSHOTSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListSnapshotsResult.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_SWAS_OPEN_MODEL_LISTSNAPSHOTSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTSNAPSHOTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ListSnapshotsResult : public ServiceResult
+			{
+			public:
+				struct Snapshot
+				{
+					std::string status;
+					std::string snapshotId;
+					std::string progress;
+					std::string creationTime;
+					std::string regionId;
+					std::string sourceDiskType;
+					std::string snapshotName;
+					std::string sourceDiskId;
+					std::string remark;
+				};
+
+
+				ListSnapshotsResult();
+				explicit ListSnapshotsResult(const std::string &payload);
+				~ListSnapshotsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Snapshot> getSnapshots()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Snapshot> snapshots_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTSNAPSHOTSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/LoginInstanceRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_LOGININSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LOGININSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT LoginInstanceRequest : public RpcServiceRequest {
+public:
+	LoginInstanceRequest();
+	~LoginInstanceRequest();
+	std::string getPassword() const;
+	void setPassword(const std::string &password);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getUsername() const;
+	void setUsername(const std::string &username);
+
+private:
+	std::string password_;
+	std::string instanceId_;
+	std::string regionId_;
+	std::string username_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LOGININSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/LoginInstanceResult.h

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

swas-open/include/alibabacloud/swas-open/model/ModifyDatabaseInstanceDescriptionRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEDESCRIPTIONREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEDESCRIPTIONREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ModifyDatabaseInstanceDescriptionRequest : public RpcServiceRequest {
+public:
+	ModifyDatabaseInstanceDescriptionRequest();
+	~ModifyDatabaseInstanceDescriptionRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDatabaseInstanceDescription() const;
+	void setDatabaseInstanceDescription(const std::string &databaseInstanceDescription);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+	std::string databaseInstanceDescription_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEDESCRIPTIONREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ModifyDatabaseInstanceDescriptionResult.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_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEDESCRIPTIONRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEDESCRIPTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ModifyDatabaseInstanceDescriptionResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyDatabaseInstanceDescriptionResult();
+				explicit ModifyDatabaseInstanceDescriptionResult(const std::string &payload);
+				~ModifyDatabaseInstanceDescriptionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEDESCRIPTIONRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ModifyDatabaseInstanceParameterRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEPARAMETERREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEPARAMETERREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ModifyDatabaseInstanceParameterRequest : public RpcServiceRequest {
+public:
+	ModifyDatabaseInstanceParameterRequest();
+	~ModifyDatabaseInstanceParameterRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getForceRestart() const;
+	void setForceRestart(bool forceRestart);
+	std::string getParameters() const;
+	void setParameters(const std::string &parameters);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+	bool forceRestart_;
+	std::string parameters_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEPARAMETERREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ModifyDatabaseInstanceParameterResult.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_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEPARAMETERRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEPARAMETERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ModifyDatabaseInstanceParameterResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyDatabaseInstanceParameterResult();
+				explicit ModifyDatabaseInstanceParameterResult(const std::string &payload);
+				~ModifyDatabaseInstanceParameterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYDATABASEINSTANCEPARAMETERRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ModifyImageShareStatusRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYIMAGESHARESTATUSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYIMAGESHARESTATUSREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ModifyImageShareStatusRequest : public RpcServiceRequest {
+public:
+	ModifyImageShareStatusRequest();
+	~ModifyImageShareStatusRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getOperation() const;
+	void setOperation(const std::string &operation);
+
+private:
+	std::string imageId_;
+	std::string clientToken_;
+	std::string regionId_;
+	std::string operation_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYIMAGESHARESTATUSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ModifyImageShareStatusResult.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_SWAS_OPEN_MODEL_MODIFYIMAGESHARESTATUSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYIMAGESHARESTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ModifyImageShareStatusResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyImageShareStatusResult();
+				explicit ModifyImageShareStatusResult(const std::string &payload);
+				~ModifyImageShareStatusResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_MODIFYIMAGESHARESTATUSRESULT_H_

swas-open/include/alibabacloud/swas-open/model/RebootInstanceRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_REBOOTINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_REBOOTINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT RebootInstanceRequest : public RpcServiceRequest {
+public:
+	RebootInstanceRequest();
+	~RebootInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_REBOOTINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/RebootInstanceResult.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_SWAS_OPEN_MODEL_REBOOTINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_REBOOTINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT RebootInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				RebootInstanceResult();
+				explicit RebootInstanceResult(const std::string &payload);
+				~RebootInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_REBOOTINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/ReleasePublicConnectionRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_RELEASEPUBLICCONNECTIONREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RELEASEPUBLICCONNECTIONREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ReleasePublicConnectionRequest : public RpcServiceRequest {
+public:
+	ReleasePublicConnectionRequest();
+	~ReleasePublicConnectionRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RELEASEPUBLICCONNECTIONREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ReleasePublicConnectionResult.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_SWAS_OPEN_MODEL_RELEASEPUBLICCONNECTIONRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RELEASEPUBLICCONNECTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ReleasePublicConnectionResult : public ServiceResult
+			{
+			public:
+
+
+				ReleasePublicConnectionResult();
+				explicit ReleasePublicConnectionResult(const std::string &payload);
+				~ReleasePublicConnectionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RELEASEPUBLICCONNECTIONRESULT_H_

swas-open/include/alibabacloud/swas-open/model/RenewInstanceRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_RENEWINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RENEWINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT RenewInstanceRequest : public RpcServiceRequest {
+public:
+	RenewInstanceRequest();
+	~RenewInstanceRequest();
+	int getPeriod() const;
+	void setPeriod(int period);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	int period_;
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RENEWINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/RenewInstanceResult.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_SWAS_OPEN_MODEL_RENEWINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RENEWINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT RenewInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				RenewInstanceResult();
+				explicit RenewInstanceResult(const std::string &payload);
+				~RenewInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RENEWINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/ResetDatabaseAccountPasswordRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDATABASEACCOUNTPASSWORDREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDATABASEACCOUNTPASSWORDREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ResetDatabaseAccountPasswordRequest : public RpcServiceRequest {
+public:
+	ResetDatabaseAccountPasswordRequest();
+	~ResetDatabaseAccountPasswordRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getAccountPassword() const;
+	void setAccountPassword(const std::string &accountPassword);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string accountPassword_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDATABASEACCOUNTPASSWORDREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ResetDatabaseAccountPasswordResult.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_SWAS_OPEN_MODEL_RESETDATABASEACCOUNTPASSWORDRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDATABASEACCOUNTPASSWORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ResetDatabaseAccountPasswordResult : public ServiceResult
+			{
+			public:
+
+
+				ResetDatabaseAccountPasswordResult();
+				explicit ResetDatabaseAccountPasswordResult(const std::string &payload);
+				~ResetDatabaseAccountPasswordResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDATABASEACCOUNTPASSWORDRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ResetDiskRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDISKREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDISKREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ResetDiskRequest : public RpcServiceRequest {
+public:
+	ResetDiskRequest();
+	~ResetDiskRequest();
+	std::string getSnapshotId() const;
+	void setSnapshotId(const std::string &snapshotId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDiskId() const;
+	void setDiskId(const std::string &diskId);
+
+private:
+	std::string snapshotId_;
+	std::string clientToken_;
+	std::string regionId_;
+	std::string diskId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDISKREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ResetDiskResult.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_SWAS_OPEN_MODEL_RESETDISKRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDISKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ResetDiskResult : public ServiceResult
+			{
+			public:
+
+
+				ResetDiskResult();
+				explicit ResetDiskResult(const std::string &payload);
+				~ResetDiskResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESETDISKRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ResetSystemRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_RESETSYSTEMREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESETSYSTEMREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT ResetSystemRequest : public RpcServiceRequest {
+public:
+	ResetSystemRequest();
+	~ResetSystemRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string imageId_;
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESETSYSTEMREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ResetSystemResult.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_SWAS_OPEN_MODEL_RESETSYSTEMRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESETSYSTEMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT ResetSystemResult : public ServiceResult
+			{
+			public:
+
+
+				ResetSystemResult();
+				explicit ResetSystemResult(const std::string &payload);
+				~ResetSystemResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESETSYSTEMRESULT_H_

swas-open/include/alibabacloud/swas-open/model/RestartDatabaseInstanceRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_RESTARTDATABASEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESTARTDATABASEINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT RestartDatabaseInstanceRequest : public RpcServiceRequest {
+public:
+	RestartDatabaseInstanceRequest();
+	~RestartDatabaseInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESTARTDATABASEINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/RestartDatabaseInstanceResult.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_SWAS_OPEN_MODEL_RESTARTDATABASEINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RESTARTDATABASEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT RestartDatabaseInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				RestartDatabaseInstanceResult();
+				explicit RestartDatabaseInstanceResult(const std::string &payload);
+				~RestartDatabaseInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RESTARTDATABASEINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/RunCommandRequest.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_SWAS_OPEN_MODEL_RUNCOMMANDREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_RUNCOMMANDREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT RunCommandRequest : public RpcServiceRequest {
+public:
+	RunCommandRequest();
+	~RunCommandRequest();
+	std::string getWorkingDir() const;
+	void setWorkingDir(const std::string &workingDir);
+	std::string getType() const;
+	void setType(const std::string &type);
+	std::string getCommandContent() const;
+	void setCommandContent(const std::string &commandContent);
+	int getTimeout() const;
+	void setTimeout(int timeout);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getWindowsPasswordName() const;
+	void setWindowsPasswordName(const std::string &windowsPasswordName);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getWorkingUser() const;
+	void setWorkingUser(const std::string &workingUser);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::map<std::string, std::string> getParameters() const;
+	void setParameters(const std::map<std::string, std::string> &parameters);
+	bool getEnableParameter() const;
+	void setEnableParameter(bool enableParameter);
+
+private:
+	std::string workingDir_;
+	std::string type_;
+	std::string commandContent_;
+	int timeout_;
+	std::string regionId_;
+	std::string windowsPasswordName_;
+	std::string instanceId_;
+	std::string workingUser_;
+	std::string name_;
+	std::map<std::string, std::string> parameters_;
+	bool enableParameter_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_RUNCOMMANDREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/RunCommandResult.h

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

swas-open/include/alibabacloud/swas-open/model/StartDatabaseInstanceRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_STARTDATABASEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STARTDATABASEINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT StartDatabaseInstanceRequest : public RpcServiceRequest {
+public:
+	StartDatabaseInstanceRequest();
+	~StartDatabaseInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STARTDATABASEINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/StartDatabaseInstanceResult.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_SWAS_OPEN_MODEL_STARTDATABASEINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STARTDATABASEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT StartDatabaseInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				StartDatabaseInstanceResult();
+				explicit StartDatabaseInstanceResult(const std::string &payload);
+				~StartDatabaseInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STARTDATABASEINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/StartInstanceRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_STARTINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STARTINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT StartInstanceRequest : public RpcServiceRequest {
+public:
+	StartInstanceRequest();
+	~StartInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STARTINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/StartInstanceResult.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_SWAS_OPEN_MODEL_STARTINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STARTINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT StartInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				StartInstanceResult();
+				explicit StartInstanceResult(const std::string &payload);
+				~StartInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STARTINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/StopDatabaseInstanceRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_STOPDATABASEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STOPDATABASEINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT StopDatabaseInstanceRequest : public RpcServiceRequest {
+public:
+	StopDatabaseInstanceRequest();
+	~StopDatabaseInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDatabaseInstanceId() const;
+	void setDatabaseInstanceId(const std::string &databaseInstanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string databaseInstanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STOPDATABASEINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/StopDatabaseInstanceResult.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_SWAS_OPEN_MODEL_STOPDATABASEINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STOPDATABASEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT StopDatabaseInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				StopDatabaseInstanceResult();
+				explicit StopDatabaseInstanceResult(const std::string &payload);
+				~StopDatabaseInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STOPDATABASEINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/StopInstanceRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_STOPINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STOPINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT StopInstanceRequest : public RpcServiceRequest {
+public:
+	StopInstanceRequest();
+	~StopInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STOPINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/StopInstanceResult.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_SWAS_OPEN_MODEL_STOPINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_STOPINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT StopInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				StopInstanceResult();
+				explicit StopInstanceResult(const std::string &payload);
+				~StopInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_STOPINSTANCERESULT_H_

swas-open/include/alibabacloud/swas-open/model/UpdateInstanceAttributeRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_UPDATEINSTANCEATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_UPDATEINSTANCEATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT UpdateInstanceAttributeRequest : public RpcServiceRequest {
+public:
+	UpdateInstanceAttributeRequest();
+	~UpdateInstanceAttributeRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getPassword() const;
+	void setPassword(const std::string &password);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getInstanceName() const;
+	void setInstanceName(const std::string &instanceName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string password_;
+	std::string instanceId_;
+	std::string instanceName_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_UPDATEINSTANCEATTRIBUTEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/UpdateInstanceAttributeResult.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_SWAS_OPEN_MODEL_UPDATEINSTANCEATTRIBUTERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_UPDATEINSTANCEATTRIBUTERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT UpdateInstanceAttributeResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateInstanceAttributeResult();
+				explicit UpdateInstanceAttributeResult(const std::string &payload);
+				~UpdateInstanceAttributeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_UPDATEINSTANCEATTRIBUTERESULT_H_

swas-open/include/alibabacloud/swas-open/model/UpgradeInstanceRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_UPGRADEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_UPGRADEINSTANCEREQUEST_H_
+
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace SWAS_OPEN {
+namespace Model {
+class ALIBABACLOUD_SWAS_OPEN_EXPORT UpgradeInstanceRequest : public RpcServiceRequest {
+public:
+	UpgradeInstanceRequest();
+	~UpgradeInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPlanId() const;
+	void setPlanId(const std::string &planId);
+
+private:
+	std::string clientToken_;
+	std::string instanceId_;
+	std::string regionId_;
+	std::string planId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_UPGRADEINSTANCEREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/UpgradeInstanceResult.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_SWAS_OPEN_MODEL_UPGRADEINSTANCERESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_UPGRADEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/swas-open/SWAS_OPENExport.h>
+
+namespace AlibabaCloud
+{
+	namespace SWAS_OPEN
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SWAS_OPEN_EXPORT UpgradeInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				UpgradeInstanceResult();
+				explicit UpgradeInstanceResult(const std::string &payload);
+				~UpgradeInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_UPGRADEINSTANCERESULT_H_

swas-open/src/SWAS-OPENClient.cc

@@ -0,0 +1,1637 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/swas-open/SWAS_OPENClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::SWAS_OPEN;
+using namespace AlibabaCloud::SWAS_OPEN::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "SWAS-OPEN";
+}
+
+SWAS_OPENClient::SWAS_OPENClient(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, "SWAS-OPEN");
+}
+
+SWAS_OPENClient::SWAS_OPENClient(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, "SWAS-OPEN");
+}
+
+SWAS_OPENClient::SWAS_OPENClient(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, "SWAS-OPEN");
+}
+
+SWAS_OPENClient::~SWAS_OPENClient()
+{}
+
+SWAS_OPENClient::AllocatePublicConnectionOutcome SWAS_OPENClient::allocatePublicConnection(const AllocatePublicConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AllocatePublicConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AllocatePublicConnectionOutcome(AllocatePublicConnectionResult(outcome.result()));
+	else
+		return AllocatePublicConnectionOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::allocatePublicConnectionAsync(const AllocatePublicConnectionRequest& request, const AllocatePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, allocatePublicConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::AllocatePublicConnectionOutcomeCallable SWAS_OPENClient::allocatePublicConnectionCallable(const AllocatePublicConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AllocatePublicConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->allocatePublicConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::CreateCustomImageOutcome SWAS_OPENClient::createCustomImage(const CreateCustomImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCustomImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCustomImageOutcome(CreateCustomImageResult(outcome.result()));
+	else
+		return CreateCustomImageOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::createCustomImageAsync(const CreateCustomImageRequest& request, const CreateCustomImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCustomImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::CreateCustomImageOutcomeCallable SWAS_OPENClient::createCustomImageCallable(const CreateCustomImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCustomImageOutcome()>>(
+			[this, request]()
+			{
+			return this->createCustomImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::CreateFirewallRuleOutcome SWAS_OPENClient::createFirewallRule(const CreateFirewallRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateFirewallRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateFirewallRuleOutcome(CreateFirewallRuleResult(outcome.result()));
+	else
+		return CreateFirewallRuleOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::createFirewallRuleAsync(const CreateFirewallRuleRequest& request, const CreateFirewallRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createFirewallRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::CreateFirewallRuleOutcomeCallable SWAS_OPENClient::createFirewallRuleCallable(const CreateFirewallRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateFirewallRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createFirewallRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::CreateInstancesOutcome SWAS_OPENClient::createInstances(const CreateInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateInstancesOutcome(CreateInstancesResult(outcome.result()));
+	else
+		return CreateInstancesOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::createInstancesAsync(const CreateInstancesRequest& request, const CreateInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::CreateInstancesOutcomeCallable SWAS_OPENClient::createInstancesCallable(const CreateInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->createInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::CreateSnapshotOutcome SWAS_OPENClient::createSnapshot(const CreateSnapshotRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateSnapshotOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateSnapshotOutcome(CreateSnapshotResult(outcome.result()));
+	else
+		return CreateSnapshotOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::createSnapshotAsync(const CreateSnapshotRequest& request, const CreateSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSnapshot(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::CreateSnapshotOutcomeCallable SWAS_OPENClient::createSnapshotCallable(const CreateSnapshotRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateSnapshotOutcome()>>(
+			[this, request]()
+			{
+			return this->createSnapshot(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DeleteCustomImageOutcome SWAS_OPENClient::deleteCustomImage(const DeleteCustomImageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteCustomImageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteCustomImageOutcome(DeleteCustomImageResult(outcome.result()));
+	else
+		return DeleteCustomImageOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::deleteCustomImageAsync(const DeleteCustomImageRequest& request, const DeleteCustomImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteCustomImage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DeleteCustomImageOutcomeCallable SWAS_OPENClient::deleteCustomImageCallable(const DeleteCustomImageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteCustomImageOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteCustomImage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DeleteFirewallRuleOutcome SWAS_OPENClient::deleteFirewallRule(const DeleteFirewallRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFirewallRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFirewallRuleOutcome(DeleteFirewallRuleResult(outcome.result()));
+	else
+		return DeleteFirewallRuleOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::deleteFirewallRuleAsync(const DeleteFirewallRuleRequest& request, const DeleteFirewallRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFirewallRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DeleteFirewallRuleOutcomeCallable SWAS_OPENClient::deleteFirewallRuleCallable(const DeleteFirewallRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFirewallRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFirewallRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DeleteSnapshotOutcome SWAS_OPENClient::deleteSnapshot(const DeleteSnapshotRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSnapshotOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSnapshotOutcome(DeleteSnapshotResult(outcome.result()));
+	else
+		return DeleteSnapshotOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::deleteSnapshotAsync(const DeleteSnapshotRequest& request, const DeleteSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSnapshot(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DeleteSnapshotOutcomeCallable SWAS_OPENClient::deleteSnapshotCallable(const DeleteSnapshotRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSnapshotOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSnapshot(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeCloudAssistantStatusOutcome SWAS_OPENClient::describeCloudAssistantStatus(const DescribeCloudAssistantStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCloudAssistantStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCloudAssistantStatusOutcome(DescribeCloudAssistantStatusResult(outcome.result()));
+	else
+		return DescribeCloudAssistantStatusOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeCloudAssistantStatusAsync(const DescribeCloudAssistantStatusRequest& request, const DescribeCloudAssistantStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCloudAssistantStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeCloudAssistantStatusOutcomeCallable SWAS_OPENClient::describeCloudAssistantStatusCallable(const DescribeCloudAssistantStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCloudAssistantStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCloudAssistantStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeDatabaseErrorLogsOutcome SWAS_OPENClient::describeDatabaseErrorLogs(const DescribeDatabaseErrorLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDatabaseErrorLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDatabaseErrorLogsOutcome(DescribeDatabaseErrorLogsResult(outcome.result()));
+	else
+		return DescribeDatabaseErrorLogsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeDatabaseErrorLogsAsync(const DescribeDatabaseErrorLogsRequest& request, const DescribeDatabaseErrorLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDatabaseErrorLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeDatabaseErrorLogsOutcomeCallable SWAS_OPENClient::describeDatabaseErrorLogsCallable(const DescribeDatabaseErrorLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDatabaseErrorLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDatabaseErrorLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeDatabaseInstanceMetricDataOutcome SWAS_OPENClient::describeDatabaseInstanceMetricData(const DescribeDatabaseInstanceMetricDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDatabaseInstanceMetricDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDatabaseInstanceMetricDataOutcome(DescribeDatabaseInstanceMetricDataResult(outcome.result()));
+	else
+		return DescribeDatabaseInstanceMetricDataOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeDatabaseInstanceMetricDataAsync(const DescribeDatabaseInstanceMetricDataRequest& request, const DescribeDatabaseInstanceMetricDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDatabaseInstanceMetricData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeDatabaseInstanceMetricDataOutcomeCallable SWAS_OPENClient::describeDatabaseInstanceMetricDataCallable(const DescribeDatabaseInstanceMetricDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDatabaseInstanceMetricDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDatabaseInstanceMetricData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeDatabaseInstanceParametersOutcome SWAS_OPENClient::describeDatabaseInstanceParameters(const DescribeDatabaseInstanceParametersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDatabaseInstanceParametersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDatabaseInstanceParametersOutcome(DescribeDatabaseInstanceParametersResult(outcome.result()));
+	else
+		return DescribeDatabaseInstanceParametersOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeDatabaseInstanceParametersAsync(const DescribeDatabaseInstanceParametersRequest& request, const DescribeDatabaseInstanceParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDatabaseInstanceParameters(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeDatabaseInstanceParametersOutcomeCallable SWAS_OPENClient::describeDatabaseInstanceParametersCallable(const DescribeDatabaseInstanceParametersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDatabaseInstanceParametersOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDatabaseInstanceParameters(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeDatabaseInstancesOutcome SWAS_OPENClient::describeDatabaseInstances(const DescribeDatabaseInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDatabaseInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDatabaseInstancesOutcome(DescribeDatabaseInstancesResult(outcome.result()));
+	else
+		return DescribeDatabaseInstancesOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeDatabaseInstancesAsync(const DescribeDatabaseInstancesRequest& request, const DescribeDatabaseInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDatabaseInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeDatabaseInstancesOutcomeCallable SWAS_OPENClient::describeDatabaseInstancesCallable(const DescribeDatabaseInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDatabaseInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDatabaseInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeDatabaseSlowLogRecordsOutcome SWAS_OPENClient::describeDatabaseSlowLogRecords(const DescribeDatabaseSlowLogRecordsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDatabaseSlowLogRecordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDatabaseSlowLogRecordsOutcome(DescribeDatabaseSlowLogRecordsResult(outcome.result()));
+	else
+		return DescribeDatabaseSlowLogRecordsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeDatabaseSlowLogRecordsAsync(const DescribeDatabaseSlowLogRecordsRequest& request, const DescribeDatabaseSlowLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDatabaseSlowLogRecords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeDatabaseSlowLogRecordsOutcomeCallable SWAS_OPENClient::describeDatabaseSlowLogRecordsCallable(const DescribeDatabaseSlowLogRecordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDatabaseSlowLogRecordsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDatabaseSlowLogRecords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeInvocationResultOutcome SWAS_OPENClient::describeInvocationResult(const DescribeInvocationResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInvocationResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInvocationResultOutcome(DescribeInvocationResultResult(outcome.result()));
+	else
+		return DescribeInvocationResultOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeInvocationResultAsync(const DescribeInvocationResultRequest& request, const DescribeInvocationResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInvocationResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeInvocationResultOutcomeCallable SWAS_OPENClient::describeInvocationResultCallable(const DescribeInvocationResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInvocationResultOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInvocationResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::DescribeInvocationsOutcome SWAS_OPENClient::describeInvocations(const DescribeInvocationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeInvocationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeInvocationsOutcome(DescribeInvocationsResult(outcome.result()));
+	else
+		return DescribeInvocationsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::describeInvocationsAsync(const DescribeInvocationsRequest& request, const DescribeInvocationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeInvocations(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DescribeInvocationsOutcomeCallable SWAS_OPENClient::describeInvocationsCallable(const DescribeInvocationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeInvocationsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeInvocations(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::InstallCloudAssistantOutcome SWAS_OPENClient::installCloudAssistant(const InstallCloudAssistantRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return InstallCloudAssistantOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return InstallCloudAssistantOutcome(InstallCloudAssistantResult(outcome.result()));
+	else
+		return InstallCloudAssistantOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::installCloudAssistantAsync(const InstallCloudAssistantRequest& request, const InstallCloudAssistantAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, installCloudAssistant(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::InstallCloudAssistantOutcomeCallable SWAS_OPENClient::installCloudAssistantCallable(const InstallCloudAssistantRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<InstallCloudAssistantOutcome()>>(
+			[this, request]()
+			{
+			return this->installCloudAssistant(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListDisksOutcome SWAS_OPENClient::listDisks(const ListDisksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDisksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDisksOutcome(ListDisksResult(outcome.result()));
+	else
+		return ListDisksOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listDisksAsync(const ListDisksRequest& request, const ListDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDisks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListDisksOutcomeCallable SWAS_OPENClient::listDisksCallable(const ListDisksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDisksOutcome()>>(
+			[this, request]()
+			{
+			return this->listDisks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListFirewallRulesOutcome SWAS_OPENClient::listFirewallRules(const ListFirewallRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListFirewallRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListFirewallRulesOutcome(ListFirewallRulesResult(outcome.result()));
+	else
+		return ListFirewallRulesOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listFirewallRulesAsync(const ListFirewallRulesRequest& request, const ListFirewallRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listFirewallRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListFirewallRulesOutcomeCallable SWAS_OPENClient::listFirewallRulesCallable(const ListFirewallRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListFirewallRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listFirewallRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListImagesOutcome SWAS_OPENClient::listImages(const ListImagesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListImagesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListImagesOutcome(ListImagesResult(outcome.result()));
+	else
+		return ListImagesOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listImagesAsync(const ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listImages(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListImagesOutcomeCallable SWAS_OPENClient::listImagesCallable(const ListImagesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListImagesOutcome()>>(
+			[this, request]()
+			{
+			return this->listImages(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListInstancePlansModificationOutcome SWAS_OPENClient::listInstancePlansModification(const ListInstancePlansModificationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListInstancePlansModificationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListInstancePlansModificationOutcome(ListInstancePlansModificationResult(outcome.result()));
+	else
+		return ListInstancePlansModificationOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listInstancePlansModificationAsync(const ListInstancePlansModificationRequest& request, const ListInstancePlansModificationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listInstancePlansModification(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListInstancePlansModificationOutcomeCallable SWAS_OPENClient::listInstancePlansModificationCallable(const ListInstancePlansModificationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListInstancePlansModificationOutcome()>>(
+			[this, request]()
+			{
+			return this->listInstancePlansModification(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListInstancesOutcome SWAS_OPENClient::listInstances(const ListInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListInstancesOutcome(ListInstancesResult(outcome.result()));
+	else
+		return ListInstancesOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listInstancesAsync(const ListInstancesRequest& request, const ListInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListInstancesOutcomeCallable SWAS_OPENClient::listInstancesCallable(const ListInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->listInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListInstancesTrafficPackagesOutcome SWAS_OPENClient::listInstancesTrafficPackages(const ListInstancesTrafficPackagesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListInstancesTrafficPackagesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListInstancesTrafficPackagesOutcome(ListInstancesTrafficPackagesResult(outcome.result()));
+	else
+		return ListInstancesTrafficPackagesOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listInstancesTrafficPackagesAsync(const ListInstancesTrafficPackagesRequest& request, const ListInstancesTrafficPackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listInstancesTrafficPackages(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListInstancesTrafficPackagesOutcomeCallable SWAS_OPENClient::listInstancesTrafficPackagesCallable(const ListInstancesTrafficPackagesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListInstancesTrafficPackagesOutcome()>>(
+			[this, request]()
+			{
+			return this->listInstancesTrafficPackages(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListPlansOutcome SWAS_OPENClient::listPlans(const ListPlansRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPlansOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPlansOutcome(ListPlansResult(outcome.result()));
+	else
+		return ListPlansOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listPlansAsync(const ListPlansRequest& request, const ListPlansAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPlans(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListPlansOutcomeCallable SWAS_OPENClient::listPlansCallable(const ListPlansRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPlansOutcome()>>(
+			[this, request]()
+			{
+			return this->listPlans(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListRegionsOutcome SWAS_OPENClient::listRegions(const ListRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListRegionsOutcome(ListRegionsResult(outcome.result()));
+	else
+		return ListRegionsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listRegionsAsync(const ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListRegionsOutcomeCallable SWAS_OPENClient::listRegionsCallable(const ListRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->listRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ListSnapshotsOutcome SWAS_OPENClient::listSnapshots(const ListSnapshotsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSnapshotsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSnapshotsOutcome(ListSnapshotsResult(outcome.result()));
+	else
+		return ListSnapshotsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listSnapshotsAsync(const ListSnapshotsRequest& request, const ListSnapshotsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSnapshots(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListSnapshotsOutcomeCallable SWAS_OPENClient::listSnapshotsCallable(const ListSnapshotsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSnapshotsOutcome()>>(
+			[this, request]()
+			{
+			return this->listSnapshots(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::LoginInstanceOutcome SWAS_OPENClient::loginInstance(const LoginInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return LoginInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return LoginInstanceOutcome(LoginInstanceResult(outcome.result()));
+	else
+		return LoginInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::loginInstanceAsync(const LoginInstanceRequest& request, const LoginInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, loginInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::LoginInstanceOutcomeCallable SWAS_OPENClient::loginInstanceCallable(const LoginInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<LoginInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->loginInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ModifyDatabaseInstanceDescriptionOutcome SWAS_OPENClient::modifyDatabaseInstanceDescription(const ModifyDatabaseInstanceDescriptionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDatabaseInstanceDescriptionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDatabaseInstanceDescriptionOutcome(ModifyDatabaseInstanceDescriptionResult(outcome.result()));
+	else
+		return ModifyDatabaseInstanceDescriptionOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::modifyDatabaseInstanceDescriptionAsync(const ModifyDatabaseInstanceDescriptionRequest& request, const ModifyDatabaseInstanceDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDatabaseInstanceDescription(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ModifyDatabaseInstanceDescriptionOutcomeCallable SWAS_OPENClient::modifyDatabaseInstanceDescriptionCallable(const ModifyDatabaseInstanceDescriptionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDatabaseInstanceDescriptionOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDatabaseInstanceDescription(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ModifyDatabaseInstanceParameterOutcome SWAS_OPENClient::modifyDatabaseInstanceParameter(const ModifyDatabaseInstanceParameterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDatabaseInstanceParameterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDatabaseInstanceParameterOutcome(ModifyDatabaseInstanceParameterResult(outcome.result()));
+	else
+		return ModifyDatabaseInstanceParameterOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::modifyDatabaseInstanceParameterAsync(const ModifyDatabaseInstanceParameterRequest& request, const ModifyDatabaseInstanceParameterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDatabaseInstanceParameter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ModifyDatabaseInstanceParameterOutcomeCallable SWAS_OPENClient::modifyDatabaseInstanceParameterCallable(const ModifyDatabaseInstanceParameterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDatabaseInstanceParameterOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDatabaseInstanceParameter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ModifyImageShareStatusOutcome SWAS_OPENClient::modifyImageShareStatus(const ModifyImageShareStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyImageShareStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyImageShareStatusOutcome(ModifyImageShareStatusResult(outcome.result()));
+	else
+		return ModifyImageShareStatusOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::modifyImageShareStatusAsync(const ModifyImageShareStatusRequest& request, const ModifyImageShareStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyImageShareStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ModifyImageShareStatusOutcomeCallable SWAS_OPENClient::modifyImageShareStatusCallable(const ModifyImageShareStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyImageShareStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyImageShareStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::RebootInstanceOutcome SWAS_OPENClient::rebootInstance(const RebootInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RebootInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RebootInstanceOutcome(RebootInstanceResult(outcome.result()));
+	else
+		return RebootInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::rebootInstanceAsync(const RebootInstanceRequest& request, const RebootInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rebootInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::RebootInstanceOutcomeCallable SWAS_OPENClient::rebootInstanceCallable(const RebootInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RebootInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->rebootInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ReleasePublicConnectionOutcome SWAS_OPENClient::releasePublicConnection(const ReleasePublicConnectionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReleasePublicConnectionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReleasePublicConnectionOutcome(ReleasePublicConnectionResult(outcome.result()));
+	else
+		return ReleasePublicConnectionOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::releasePublicConnectionAsync(const ReleasePublicConnectionRequest& request, const ReleasePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, releasePublicConnection(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ReleasePublicConnectionOutcomeCallable SWAS_OPENClient::releasePublicConnectionCallable(const ReleasePublicConnectionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReleasePublicConnectionOutcome()>>(
+			[this, request]()
+			{
+			return this->releasePublicConnection(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::RenewInstanceOutcome SWAS_OPENClient::renewInstance(const RenewInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RenewInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RenewInstanceOutcome(RenewInstanceResult(outcome.result()));
+	else
+		return RenewInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::renewInstanceAsync(const RenewInstanceRequest& request, const RenewInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, renewInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::RenewInstanceOutcomeCallable SWAS_OPENClient::renewInstanceCallable(const RenewInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RenewInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->renewInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ResetDatabaseAccountPasswordOutcome SWAS_OPENClient::resetDatabaseAccountPassword(const ResetDatabaseAccountPasswordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResetDatabaseAccountPasswordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResetDatabaseAccountPasswordOutcome(ResetDatabaseAccountPasswordResult(outcome.result()));
+	else
+		return ResetDatabaseAccountPasswordOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::resetDatabaseAccountPasswordAsync(const ResetDatabaseAccountPasswordRequest& request, const ResetDatabaseAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resetDatabaseAccountPassword(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ResetDatabaseAccountPasswordOutcomeCallable SWAS_OPENClient::resetDatabaseAccountPasswordCallable(const ResetDatabaseAccountPasswordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResetDatabaseAccountPasswordOutcome()>>(
+			[this, request]()
+			{
+			return this->resetDatabaseAccountPassword(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ResetDiskOutcome SWAS_OPENClient::resetDisk(const ResetDiskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResetDiskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResetDiskOutcome(ResetDiskResult(outcome.result()));
+	else
+		return ResetDiskOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::resetDiskAsync(const ResetDiskRequest& request, const ResetDiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resetDisk(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ResetDiskOutcomeCallable SWAS_OPENClient::resetDiskCallable(const ResetDiskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResetDiskOutcome()>>(
+			[this, request]()
+			{
+			return this->resetDisk(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::ResetSystemOutcome SWAS_OPENClient::resetSystem(const ResetSystemRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResetSystemOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResetSystemOutcome(ResetSystemResult(outcome.result()));
+	else
+		return ResetSystemOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::resetSystemAsync(const ResetSystemRequest& request, const ResetSystemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resetSystem(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ResetSystemOutcomeCallable SWAS_OPENClient::resetSystemCallable(const ResetSystemRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResetSystemOutcome()>>(
+			[this, request]()
+			{
+			return this->resetSystem(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::RestartDatabaseInstanceOutcome SWAS_OPENClient::restartDatabaseInstance(const RestartDatabaseInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RestartDatabaseInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RestartDatabaseInstanceOutcome(RestartDatabaseInstanceResult(outcome.result()));
+	else
+		return RestartDatabaseInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::restartDatabaseInstanceAsync(const RestartDatabaseInstanceRequest& request, const RestartDatabaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, restartDatabaseInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::RestartDatabaseInstanceOutcomeCallable SWAS_OPENClient::restartDatabaseInstanceCallable(const RestartDatabaseInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RestartDatabaseInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->restartDatabaseInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::RunCommandOutcome SWAS_OPENClient::runCommand(const RunCommandRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RunCommandOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RunCommandOutcome(RunCommandResult(outcome.result()));
+	else
+		return RunCommandOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::runCommandAsync(const RunCommandRequest& request, const RunCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, runCommand(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::RunCommandOutcomeCallable SWAS_OPENClient::runCommandCallable(const RunCommandRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RunCommandOutcome()>>(
+			[this, request]()
+			{
+			return this->runCommand(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::StartDatabaseInstanceOutcome SWAS_OPENClient::startDatabaseInstance(const StartDatabaseInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartDatabaseInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartDatabaseInstanceOutcome(StartDatabaseInstanceResult(outcome.result()));
+	else
+		return StartDatabaseInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::startDatabaseInstanceAsync(const StartDatabaseInstanceRequest& request, const StartDatabaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startDatabaseInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::StartDatabaseInstanceOutcomeCallable SWAS_OPENClient::startDatabaseInstanceCallable(const StartDatabaseInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartDatabaseInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->startDatabaseInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::StartInstanceOutcome SWAS_OPENClient::startInstance(const StartInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartInstanceOutcome(StartInstanceResult(outcome.result()));
+	else
+		return StartInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::startInstanceAsync(const StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::StartInstanceOutcomeCallable SWAS_OPENClient::startInstanceCallable(const StartInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->startInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::StopDatabaseInstanceOutcome SWAS_OPENClient::stopDatabaseInstance(const StopDatabaseInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopDatabaseInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopDatabaseInstanceOutcome(StopDatabaseInstanceResult(outcome.result()));
+	else
+		return StopDatabaseInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::stopDatabaseInstanceAsync(const StopDatabaseInstanceRequest& request, const StopDatabaseInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopDatabaseInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::StopDatabaseInstanceOutcomeCallable SWAS_OPENClient::stopDatabaseInstanceCallable(const StopDatabaseInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopDatabaseInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->stopDatabaseInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::StopInstanceOutcome SWAS_OPENClient::stopInstance(const StopInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopInstanceOutcome(StopInstanceResult(outcome.result()));
+	else
+		return StopInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::stopInstanceAsync(const StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::StopInstanceOutcomeCallable SWAS_OPENClient::stopInstanceCallable(const StopInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->stopInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::UpdateInstanceAttributeOutcome SWAS_OPENClient::updateInstanceAttribute(const UpdateInstanceAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateInstanceAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateInstanceAttributeOutcome(UpdateInstanceAttributeResult(outcome.result()));
+	else
+		return UpdateInstanceAttributeOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::updateInstanceAttributeAsync(const UpdateInstanceAttributeRequest& request, const UpdateInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateInstanceAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::UpdateInstanceAttributeOutcomeCallable SWAS_OPENClient::updateInstanceAttributeCallable(const UpdateInstanceAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateInstanceAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateInstanceAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SWAS_OPENClient::UpgradeInstanceOutcome SWAS_OPENClient::upgradeInstance(const UpgradeInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpgradeInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpgradeInstanceOutcome(UpgradeInstanceResult(outcome.result()));
+	else
+		return UpgradeInstanceOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::upgradeInstanceAsync(const UpgradeInstanceRequest& request, const UpgradeInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, upgradeInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::UpgradeInstanceOutcomeCallable SWAS_OPENClient::upgradeInstanceCallable(const UpgradeInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpgradeInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->upgradeInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

swas-open/src/model/AllocatePublicConnectionRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/swas-open/model/AllocatePublicConnectionRequest.h>
+
+using AlibabaCloud::SWAS_OPEN::Model::AllocatePublicConnectionRequest;
+
+AllocatePublicConnectionRequest::AllocatePublicConnectionRequest()
+    : RpcServiceRequest("swas-open", "2020-06-01", "AllocatePublicConnection") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AllocatePublicConnectionRequest::~AllocatePublicConnectionRequest() {}
+
+std::string AllocatePublicConnectionRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AllocatePublicConnectionRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AllocatePublicConnectionRequest::getDatabaseInstanceId() const {
+  return databaseInstanceId_;
+}
+
+void AllocatePublicConnectionRequest::setDatabaseInstanceId(const std::string &databaseInstanceId) {
+  databaseInstanceId_ = databaseInstanceId;
+  setParameter(std::string("DatabaseInstanceId"), databaseInstanceId);
+}
+
+std::string AllocatePublicConnectionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AllocatePublicConnectionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

swas-open/src/model/AllocatePublicConnectionResult.cc

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

swas-open/src/model/CreateCustomImageRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/swas-open/model/CreateCustomImageRequest.h>
+
+using AlibabaCloud::SWAS_OPEN::Model::CreateCustomImageRequest;
+
+CreateCustomImageRequest::CreateCustomImageRequest()
+    : RpcServiceRequest("swas-open", "2020-06-01", "CreateCustomImage") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateCustomImageRequest::~CreateCustomImageRequest() {}
+
+std::string CreateCustomImageRequest::getSystemSnapshotId() const {
+  return systemSnapshotId_;
+}
+
+void CreateCustomImageRequest::setSystemSnapshotId(const std::string &systemSnapshotId) {
+  systemSnapshotId_ = systemSnapshotId;
+  setParameter(std::string("SystemSnapshotId"), systemSnapshotId);
+}
+
+std::string CreateCustomImageRequest::getDataSnapshotId() const {
+  return dataSnapshotId_;
+}
+
+void CreateCustomImageRequest::setDataSnapshotId(const std::string &dataSnapshotId) {
+  dataSnapshotId_ = dataSnapshotId;
+  setParameter(std::string("DataSnapshotId"), dataSnapshotId);
+}
+
+std::string CreateCustomImageRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateCustomImageRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateCustomImageRequest::getDescription() const {
+  return description_;
+}
+
+void CreateCustomImageRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::string CreateCustomImageRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CreateCustomImageRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string CreateCustomImageRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateCustomImageRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateCustomImageRequest::getImageName() const {
+  return imageName_;
+}
+
+void CreateCustomImageRequest::setImageName(const std::string &imageName) {
+  imageName_ = imageName;
+  setParameter(std::string("ImageName"), imageName);
+}
+

swas-open/src/model/CreateCustomImageResult.cc

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

swas-open/src/model/CreateFirewallRuleRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/swas-open/model/CreateFirewallRuleRequest.h>
+
+using AlibabaCloud::SWAS_OPEN::Model::CreateFirewallRuleRequest;
+
+CreateFirewallRuleRequest::CreateFirewallRuleRequest()
+    : RpcServiceRequest("swas-open", "2020-06-01", "CreateFirewallRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateFirewallRuleRequest::~CreateFirewallRuleRequest() {}
+
+std::string CreateFirewallRuleRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateFirewallRuleRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateFirewallRuleRequest::getRemark() const {
+  return remark_;
+}
+
+void CreateFirewallRuleRequest::setRemark(const std::string &remark) {
+  remark_ = remark;
+  setParameter(std::string("Remark"), remark);
+}
+
+std::string CreateFirewallRuleRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void CreateFirewallRuleRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string CreateFirewallRuleRequest::getRuleProtocol() const {
+  return ruleProtocol_;
+}
+
+void CreateFirewallRuleRequest::setRuleProtocol(const std::string &ruleProtocol) {
+  ruleProtocol_ = ruleProtocol;
+  setParameter(std::string("RuleProtocol"), ruleProtocol);
+}
+
+std::string CreateFirewallRuleRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateFirewallRuleRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateFirewallRuleRequest::getPort() const {
+  return port_;
+}
+
+void CreateFirewallRuleRequest::setPort(const std::string &port) {
+  port_ = port;
+  setParameter(std::string("Port"), port);
+}
+

swas-open/src/model/CreateFirewallRuleResult.cc

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

swas-open/src/model/CreateInstancesRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/swas-open/model/CreateInstancesRequest.h>
+
+using AlibabaCloud::SWAS_OPEN::Model::CreateInstancesRequest;
+
+CreateInstancesRequest::CreateInstancesRequest()
+    : RpcServiceRequest("swas-open", "2020-06-01", "CreateInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateInstancesRequest::~CreateInstancesRequest() {}
+
+std::string CreateInstancesRequest::getImageId() const {
+  return imageId_;
+}
+
+void CreateInstancesRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string CreateInstancesRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateInstancesRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateInstancesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateInstancesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int CreateInstancesRequest::getAutoRenewPeriod() const {
+  return autoRenewPeriod_;
+}
+
+void CreateInstancesRequest::setAutoRenewPeriod(int autoRenewPeriod) {
+  autoRenewPeriod_ = autoRenewPeriod;
+  setParameter(std::string("AutoRenewPeriod"), std::to_string(autoRenewPeriod));
+}
+
+int CreateInstancesRequest::getPeriod() const {
+  return period_;
+}
+
+void CreateInstancesRequest::setPeriod(int period) {
+  period_ = period;
+  setParameter(std::string("Period"), std::to_string(period));
+}
+
+int CreateInstancesRequest::getAmount() const {
+  return amount_;
+}
+
+void CreateInstancesRequest::setAmount(int amount) {
+  amount_ = amount;
+  setParameter(std::string("Amount"), std::to_string(amount));
+}
+
+bool CreateInstancesRequest::getAutoRenew() const {
+  return autoRenew_;
+}
+
+void CreateInstancesRequest::setAutoRenew(bool autoRenew) {
+  autoRenew_ = autoRenew;
+  setParameter(std::string("AutoRenew"), autoRenew ? "true" : "false");
+}
+
+long CreateInstancesRequest::getDataDiskSize() const {
+  return dataDiskSize_;
+}
+
+void CreateInstancesRequest::setDataDiskSize(long dataDiskSize) {
+  dataDiskSize_ = dataDiskSize;
+  setParameter(std::string("DataDiskSize"), std::to_string(dataDiskSize));
+}
+
+std::string CreateInstancesRequest::getPlanId() const {
+  return planId_;
+}
+
+void CreateInstancesRequest::setPlanId(const std::string &planId) {
+  planId_ = planId;
+  setParameter(std::string("PlanId"), planId);
+}
+
+std::string CreateInstancesRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void CreateInstancesRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
+}
+