Generated 2020-06-01 for SWAS-OPEN.

VERSION

@@ -1 +1 @@
-1.36.1932
+1.36.1933

swas-open/CMakeLists.txt

@@ -23,6 +23,8 @@ set(swas-open_public_header
 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/AttachKeyPairRequest.h
+	include/alibabacloud/swas-open/model/AttachKeyPairResult.h
 	include/alibabacloud/swas-open/model/CreateCommandRequest.h
 	include/alibabacloud/swas-open/model/CreateCommandResult.h
 	include/alibabacloud/swas-open/model/CreateCustomImageRequest.h
@@ -35,6 +37,8 @@ set(swas-open_public_header_model
 	include/alibabacloud/swas-open/model/CreateInstanceKeyPairResult.h
 	include/alibabacloud/swas-open/model/CreateInstancesRequest.h
 	include/alibabacloud/swas-open/model/CreateInstancesResult.h
+	include/alibabacloud/swas-open/model/CreateKeyPairRequest.h
+	include/alibabacloud/swas-open/model/CreateKeyPairResult.h
 	include/alibabacloud/swas-open/model/CreateSnapshotRequest.h
 	include/alibabacloud/swas-open/model/CreateSnapshotResult.h
 	include/alibabacloud/swas-open/model/DeleteCommandRequest.h
@@ -49,6 +53,8 @@ set(swas-open_public_header_model
 	include/alibabacloud/swas-open/model/DeleteFirewallRulesResult.h
 	include/alibabacloud/swas-open/model/DeleteInstanceKeyPairRequest.h
 	include/alibabacloud/swas-open/model/DeleteInstanceKeyPairResult.h
+	include/alibabacloud/swas-open/model/DeleteKeyPairsRequest.h
+	include/alibabacloud/swas-open/model/DeleteKeyPairsResult.h
 	include/alibabacloud/swas-open/model/DeleteSnapshotRequest.h
 	include/alibabacloud/swas-open/model/DeleteSnapshotResult.h
 	include/alibabacloud/swas-open/model/DeleteSnapshotsRequest.h
@@ -87,10 +93,14 @@ set(swas-open_public_header_model
 	include/alibabacloud/swas-open/model/DescribeMonitorDataResult.h
 	include/alibabacloud/swas-open/model/DescribeSecurityAgentStatusRequest.h
 	include/alibabacloud/swas-open/model/DescribeSecurityAgentStatusResult.h
+	include/alibabacloud/swas-open/model/DetachKeyPairRequest.h
+	include/alibabacloud/swas-open/model/DetachKeyPairResult.h
 	include/alibabacloud/swas-open/model/DisableFirewallRuleRequest.h
 	include/alibabacloud/swas-open/model/DisableFirewallRuleResult.h
 	include/alibabacloud/swas-open/model/EnableFirewallRuleRequest.h
 	include/alibabacloud/swas-open/model/EnableFirewallRuleResult.h
+	include/alibabacloud/swas-open/model/ImportKeyPairRequest.h
+	include/alibabacloud/swas-open/model/ImportKeyPairResult.h
 	include/alibabacloud/swas-open/model/InstallCloudAssistantRequest.h
 	include/alibabacloud/swas-open/model/InstallCloudAssistantResult.h
 	include/alibabacloud/swas-open/model/InstallCloudMonitorAgentRequest.h
@@ -113,6 +123,8 @@ set(swas-open_public_header_model
 	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/ListKeyPairsRequest.h
+	include/alibabacloud/swas-open/model/ListKeyPairsResult.h
 	include/alibabacloud/swas-open/model/ListPlansRequest.h
 	include/alibabacloud/swas-open/model/ListPlansResult.h
 	include/alibabacloud/swas-open/model/ListRegionsRequest.h
@@ -186,6 +198,8 @@ set(swas-open_src
 	src/SWAS-OPENClient.cc
 	src/model/AllocatePublicConnectionRequest.cc
 	src/model/AllocatePublicConnectionResult.cc
+	src/model/AttachKeyPairRequest.cc
+	src/model/AttachKeyPairResult.cc
 	src/model/CreateCommandRequest.cc
 	src/model/CreateCommandResult.cc
 	src/model/CreateCustomImageRequest.cc
@@ -198,6 +212,8 @@ set(swas-open_src
 	src/model/CreateInstanceKeyPairResult.cc
 	src/model/CreateInstancesRequest.cc
 	src/model/CreateInstancesResult.cc
+	src/model/CreateKeyPairRequest.cc
+	src/model/CreateKeyPairResult.cc
 	src/model/CreateSnapshotRequest.cc
 	src/model/CreateSnapshotResult.cc
 	src/model/DeleteCommandRequest.cc
@@ -212,6 +228,8 @@ set(swas-open_src
 	src/model/DeleteFirewallRulesResult.cc
 	src/model/DeleteInstanceKeyPairRequest.cc
 	src/model/DeleteInstanceKeyPairResult.cc
+	src/model/DeleteKeyPairsRequest.cc
+	src/model/DeleteKeyPairsResult.cc
 	src/model/DeleteSnapshotRequest.cc
 	src/model/DeleteSnapshotResult.cc
 	src/model/DeleteSnapshotsRequest.cc
@@ -250,10 +268,14 @@ set(swas-open_src
 	src/model/DescribeMonitorDataResult.cc
 	src/model/DescribeSecurityAgentStatusRequest.cc
 	src/model/DescribeSecurityAgentStatusResult.cc
+	src/model/DetachKeyPairRequest.cc
+	src/model/DetachKeyPairResult.cc
 	src/model/DisableFirewallRuleRequest.cc
 	src/model/DisableFirewallRuleResult.cc
 	src/model/EnableFirewallRuleRequest.cc
 	src/model/EnableFirewallRuleResult.cc
+	src/model/ImportKeyPairRequest.cc
+	src/model/ImportKeyPairResult.cc
 	src/model/InstallCloudAssistantRequest.cc
 	src/model/InstallCloudAssistantResult.cc
 	src/model/InstallCloudMonitorAgentRequest.cc
@@ -276,6 +298,8 @@ set(swas-open_src
 	src/model/ListInstancesResult.cc
 	src/model/ListInstancesTrafficPackagesRequest.cc
 	src/model/ListInstancesTrafficPackagesResult.cc
+	src/model/ListKeyPairsRequest.cc
+	src/model/ListKeyPairsResult.cc
 	src/model/ListPlansRequest.cc
 	src/model/ListPlansResult.cc
 	src/model/ListRegionsRequest.cc

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

@@ -24,6 +24,8 @@
 #include "SWAS_OPENExport.h"
 #include "model/AllocatePublicConnectionRequest.h"
 #include "model/AllocatePublicConnectionResult.h"
+#include "model/AttachKeyPairRequest.h"
+#include "model/AttachKeyPairResult.h"
 #include "model/CreateCommandRequest.h"
 #include "model/CreateCommandResult.h"
 #include "model/CreateCustomImageRequest.h"
@@ -36,6 +38,8 @@
 #include "model/CreateInstanceKeyPairResult.h"
 #include "model/CreateInstancesRequest.h"
 #include "model/CreateInstancesResult.h"
+#include "model/CreateKeyPairRequest.h"
+#include "model/CreateKeyPairResult.h"
 #include "model/CreateSnapshotRequest.h"
 #include "model/CreateSnapshotResult.h"
 #include "model/DeleteCommandRequest.h"
@@ -50,6 +54,8 @@
 #include "model/DeleteFirewallRulesResult.h"
 #include "model/DeleteInstanceKeyPairRequest.h"
 #include "model/DeleteInstanceKeyPairResult.h"
+#include "model/DeleteKeyPairsRequest.h"
+#include "model/DeleteKeyPairsResult.h"
 #include "model/DeleteSnapshotRequest.h"
 #include "model/DeleteSnapshotResult.h"
 #include "model/DeleteSnapshotsRequest.h"
@@ -88,10 +94,14 @@
 #include "model/DescribeMonitorDataResult.h"
 #include "model/DescribeSecurityAgentStatusRequest.h"
 #include "model/DescribeSecurityAgentStatusResult.h"
+#include "model/DetachKeyPairRequest.h"
+#include "model/DetachKeyPairResult.h"
 #include "model/DisableFirewallRuleRequest.h"
 #include "model/DisableFirewallRuleResult.h"
 #include "model/EnableFirewallRuleRequest.h"
 #include "model/EnableFirewallRuleResult.h"
+#include "model/ImportKeyPairRequest.h"
+#include "model/ImportKeyPairResult.h"
 #include "model/InstallCloudAssistantRequest.h"
 #include "model/InstallCloudAssistantResult.h"
 #include "model/InstallCloudMonitorAgentRequest.h"
@@ -114,6 +124,8 @@
 #include "model/ListInstancesResult.h"
 #include "model/ListInstancesTrafficPackagesRequest.h"
 #include "model/ListInstancesTrafficPackagesResult.h"
+#include "model/ListKeyPairsRequest.h"
+#include "model/ListKeyPairsResult.h"
 #include "model/ListPlansRequest.h"
 #include "model/ListPlansResult.h"
 #include "model/ListRegionsRequest.h"
@@ -194,6 +206,9 @@ namespace AlibabaCloud
 			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::AttachKeyPairResult> AttachKeyPairOutcome;
+			typedef std::future<AttachKeyPairOutcome> AttachKeyPairOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::AttachKeyPairRequest&, const AttachKeyPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachKeyPairAsyncHandler;
 			typedef Outcome<Error, Model::CreateCommandResult> CreateCommandOutcome;
 			typedef std::future<CreateCommandOutcome> CreateCommandOutcomeCallable;
 			typedef std::function<void(const SWAS_OPENClient*, const Model::CreateCommandRequest&, const CreateCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCommandAsyncHandler;
@@ -212,6 +227,9 @@ namespace AlibabaCloud
 			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::CreateKeyPairResult> CreateKeyPairOutcome;
+			typedef std::future<CreateKeyPairOutcome> CreateKeyPairOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::CreateKeyPairRequest&, const CreateKeyPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateKeyPairAsyncHandler;
 			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;
@@ -233,6 +251,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteInstanceKeyPairResult> DeleteInstanceKeyPairOutcome;
 			typedef std::future<DeleteInstanceKeyPairOutcome> DeleteInstanceKeyPairOutcomeCallable;
 			typedef std::function<void(const SWAS_OPENClient*, const Model::DeleteInstanceKeyPairRequest&, const DeleteInstanceKeyPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteInstanceKeyPairAsyncHandler;
+			typedef Outcome<Error, Model::DeleteKeyPairsResult> DeleteKeyPairsOutcome;
+			typedef std::future<DeleteKeyPairsOutcome> DeleteKeyPairsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DeleteKeyPairsRequest&, const DeleteKeyPairsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteKeyPairsAsyncHandler;
 			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;
@@ -290,12 +311,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeSecurityAgentStatusResult> DescribeSecurityAgentStatusOutcome;
 			typedef std::future<DescribeSecurityAgentStatusOutcome> DescribeSecurityAgentStatusOutcomeCallable;
 			typedef std::function<void(const SWAS_OPENClient*, const Model::DescribeSecurityAgentStatusRequest&, const DescribeSecurityAgentStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityAgentStatusAsyncHandler;
+			typedef Outcome<Error, Model::DetachKeyPairResult> DetachKeyPairOutcome;
+			typedef std::future<DetachKeyPairOutcome> DetachKeyPairOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::DetachKeyPairRequest&, const DetachKeyPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachKeyPairAsyncHandler;
 			typedef Outcome<Error, Model::DisableFirewallRuleResult> DisableFirewallRuleOutcome;
 			typedef std::future<DisableFirewallRuleOutcome> DisableFirewallRuleOutcomeCallable;
 			typedef std::function<void(const SWAS_OPENClient*, const Model::DisableFirewallRuleRequest&, const DisableFirewallRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableFirewallRuleAsyncHandler;
 			typedef Outcome<Error, Model::EnableFirewallRuleResult> EnableFirewallRuleOutcome;
 			typedef std::future<EnableFirewallRuleOutcome> EnableFirewallRuleOutcomeCallable;
 			typedef std::function<void(const SWAS_OPENClient*, const Model::EnableFirewallRuleRequest&, const EnableFirewallRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableFirewallRuleAsyncHandler;
+			typedef Outcome<Error, Model::ImportKeyPairResult> ImportKeyPairOutcome;
+			typedef std::future<ImportKeyPairOutcome> ImportKeyPairOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ImportKeyPairRequest&, const ImportKeyPairOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportKeyPairAsyncHandler;
 			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;
@@ -329,6 +356,9 @@ namespace AlibabaCloud
 			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::ListKeyPairsResult> ListKeyPairsOutcome;
+			typedef std::future<ListKeyPairsOutcome> ListKeyPairsOutcomeCallable;
+			typedef std::function<void(const SWAS_OPENClient*, const Model::ListKeyPairsRequest&, const ListKeyPairsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListKeyPairsAsyncHandler;
 			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;
@@ -439,6 +469,9 @@ namespace AlibabaCloud
 			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;
+			AttachKeyPairOutcome attachKeyPair(const Model::AttachKeyPairRequest &request)const;
+			void attachKeyPairAsync(const Model::AttachKeyPairRequest& request, const AttachKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachKeyPairOutcomeCallable attachKeyPairCallable(const Model::AttachKeyPairRequest& request) const;
 			CreateCommandOutcome createCommand(const Model::CreateCommandRequest &request)const;
 			void createCommandAsync(const Model::CreateCommandRequest& request, const CreateCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCommandOutcomeCallable createCommandCallable(const Model::CreateCommandRequest& request) const;
@@ -457,6 +490,9 @@ namespace AlibabaCloud
 			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;
+			CreateKeyPairOutcome createKeyPair(const Model::CreateKeyPairRequest &request)const;
+			void createKeyPairAsync(const Model::CreateKeyPairRequest& request, const CreateKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateKeyPairOutcomeCallable createKeyPairCallable(const Model::CreateKeyPairRequest& 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;
@@ -478,6 +514,9 @@ namespace AlibabaCloud
 			DeleteInstanceKeyPairOutcome deleteInstanceKeyPair(const Model::DeleteInstanceKeyPairRequest &request)const;
 			void deleteInstanceKeyPairAsync(const Model::DeleteInstanceKeyPairRequest& request, const DeleteInstanceKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteInstanceKeyPairOutcomeCallable deleteInstanceKeyPairCallable(const Model::DeleteInstanceKeyPairRequest& request) const;
+			DeleteKeyPairsOutcome deleteKeyPairs(const Model::DeleteKeyPairsRequest &request)const;
+			void deleteKeyPairsAsync(const Model::DeleteKeyPairsRequest& request, const DeleteKeyPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteKeyPairsOutcomeCallable deleteKeyPairsCallable(const Model::DeleteKeyPairsRequest& 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;
@@ -535,12 +574,18 @@ namespace AlibabaCloud
 			DescribeSecurityAgentStatusOutcome describeSecurityAgentStatus(const Model::DescribeSecurityAgentStatusRequest &request)const;
 			void describeSecurityAgentStatusAsync(const Model::DescribeSecurityAgentStatusRequest& request, const DescribeSecurityAgentStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSecurityAgentStatusOutcomeCallable describeSecurityAgentStatusCallable(const Model::DescribeSecurityAgentStatusRequest& request) const;
+			DetachKeyPairOutcome detachKeyPair(const Model::DetachKeyPairRequest &request)const;
+			void detachKeyPairAsync(const Model::DetachKeyPairRequest& request, const DetachKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachKeyPairOutcomeCallable detachKeyPairCallable(const Model::DetachKeyPairRequest& request) const;
 			DisableFirewallRuleOutcome disableFirewallRule(const Model::DisableFirewallRuleRequest &request)const;
 			void disableFirewallRuleAsync(const Model::DisableFirewallRuleRequest& request, const DisableFirewallRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DisableFirewallRuleOutcomeCallable disableFirewallRuleCallable(const Model::DisableFirewallRuleRequest& request) const;
 			EnableFirewallRuleOutcome enableFirewallRule(const Model::EnableFirewallRuleRequest &request)const;
 			void enableFirewallRuleAsync(const Model::EnableFirewallRuleRequest& request, const EnableFirewallRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableFirewallRuleOutcomeCallable enableFirewallRuleCallable(const Model::EnableFirewallRuleRequest& request) const;
+			ImportKeyPairOutcome importKeyPair(const Model::ImportKeyPairRequest &request)const;
+			void importKeyPairAsync(const Model::ImportKeyPairRequest& request, const ImportKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImportKeyPairOutcomeCallable importKeyPairCallable(const Model::ImportKeyPairRequest& 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;
@@ -574,6 +619,9 @@ namespace AlibabaCloud
 			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;
+			ListKeyPairsOutcome listKeyPairs(const Model::ListKeyPairsRequest &request)const;
+			void listKeyPairsAsync(const Model::ListKeyPairsRequest& request, const ListKeyPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListKeyPairsOutcomeCallable listKeyPairsCallable(const Model::ListKeyPairsRequest& 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;

swas-open/include/alibabacloud/swas-open/model/AttachKeyPairRequest.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_ATTACHKEYPAIRREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_ATTACHKEYPAIRREQUEST_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 AttachKeyPairRequest : public RpcServiceRequest {
+public:
+	AttachKeyPairRequest();
+	~AttachKeyPairRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getKeyPairName() const;
+	void setKeyPairName(const std::string &keyPairName);
+	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 clientToken_;
+	std::string keyPairName_;
+	std::string regionId_;
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_ATTACHKEYPAIRREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/AttachKeyPairResult.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_ATTACHKEYPAIRRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_ATTACHKEYPAIRRESULT_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 AttachKeyPairResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					std::string message;
+					std::string instanceId;
+					std::string code;
+					std::string success;
+				};
+
+
+				AttachKeyPairResult();
+				explicit AttachKeyPairResult(const std::string &payload);
+				~AttachKeyPairResult();
+				int getTotalCount()const;
+				std::vector<Result> getResults()const;
+				int getFailCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<Result> results_;
+				int failCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_ATTACHKEYPAIRRESULT_H_

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

@@ -44,6 +44,8 @@ public:
 	void setCommandContent(const std::string &commandContent);
 	long getTimeout() const;
 	void setTimeout(long timeout);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::vector<Tag> getTag() const;
@@ -59,6 +61,7 @@ private:
 	std::string type_;
 	std::string commandContent_;
 	long timeout_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::vector<Tag> tag_;
 	std::string name_;

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

@@ -42,6 +42,8 @@ public:
 	void setClientToken(const std::string &clientToken);
 	std::string getDescription() const;
 	void setDescription(const std::string &description);
+	std::string getResoureGroupId() const;
+	void setResoureGroupId(const std::string &resoureGroupId);
 	std::string getPlatform() const;
 	void setPlatform(const std::string &platform);
 	std::string getRegionId() const;
@@ -58,6 +60,7 @@ private:
 	std::string dataSnapshotId_;
 	std::string clientToken_;
 	std::string description_;
+	std::string resoureGroupId_;
 	std::string platform_;
 	std::string regionId_;
 	std::string imageName_;

swas-open/include/alibabacloud/swas-open/model/CreateKeyPairRequest.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_CREATEKEYPAIRREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEKEYPAIRREQUEST_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 CreateKeyPairRequest : public RpcServiceRequest {
+public:
+	CreateKeyPairRequest();
+	~CreateKeyPairRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getKeyPairName() const;
+	void setKeyPairName(const std::string &keyPairName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string keyPairName_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEKEYPAIRREQUEST_H_

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEKEYPAIRRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEKEYPAIRRESULT_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 CreateKeyPairResult : public ServiceResult
+			{
+			public:
+
+
+				CreateKeyPairResult();
+				explicit CreateKeyPairResult(const std::string &payload);
+				~CreateKeyPairResult();
+				std::string getKeyPairName()const;
+				std::string getPrivateKeyBody()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string keyPairName_;
+				std::string privateKeyBody_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_CREATEKEYPAIRRESULT_H_

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

@@ -38,6 +38,8 @@ public:
 	void setClientToken(const std::string &clientToken);
 	std::string getSnapshotName() const;
 	void setSnapshotName(const std::string &snapshotName);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getDiskId() const;
@@ -48,6 +50,7 @@ public:
 private:
 	std::string clientToken_;
 	std::string snapshotName_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::string diskId_;
 	std::vector<Tag> tag_;

swas-open/include/alibabacloud/swas-open/model/DeleteKeyPairsRequest.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_DELETEKEYPAIRSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEKEYPAIRSREQUEST_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 DeleteKeyPairsRequest : public RpcServiceRequest {
+public:
+	DeleteKeyPairsRequest();
+	~DeleteKeyPairsRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<std::string> getKeyPairNames() const;
+	void setKeyPairNames(const std::vector<std::string> &keyPairNames);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::vector<std::string> keyPairNames_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEKEYPAIRSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DeleteKeyPairsResult.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_DELETEKEYPAIRSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEKEYPAIRSRESULT_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 DeleteKeyPairsResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteKeyPairsResult();
+				explicit DeleteKeyPairsResult(const std::string &payload);
+				~DeleteKeyPairsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DELETEKEYPAIRSRESULT_H_

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

@@ -40,6 +40,8 @@ public:
 	void setCommandId(const std::string &commandId);
 	std::string getPageNumber() const;
 	void setPageNumber(const std::string &pageNumber);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getProvider() const;
@@ -55,6 +57,7 @@ private:
 	std::string type_;
 	std::string commandId_;
 	std::string pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::string provider_;
 	std::string pageSize_;

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

@@ -49,6 +49,7 @@ namespace AlibabaCloud
 					};
 					std::vector<Command::ParameterDefinition> parameterDefinitions;
 					std::string description;
+					std::string resourceGroupId;
 					std::vector<std::string> parameterNames;
 					long timeout;
 					std::string name;

swas-open/include/alibabacloud/swas-open/model/DetachKeyPairRequest.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_DETACHKEYPAIRREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DETACHKEYPAIRREQUEST_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 DetachKeyPairRequest : public RpcServiceRequest {
+public:
+	DetachKeyPairRequest();
+	~DetachKeyPairRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getKeyPairName() const;
+	void setKeyPairName(const std::string &keyPairName);
+	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 clientToken_;
+	std::string keyPairName_;
+	std::string regionId_;
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DETACHKEYPAIRREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/DetachKeyPairResult.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_DETACHKEYPAIRRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_DETACHKEYPAIRRESULT_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 DetachKeyPairResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					std::string message;
+					std::string instanceId;
+					std::string code;
+					std::string success;
+				};
+
+
+				DetachKeyPairResult();
+				explicit DetachKeyPairResult(const std::string &payload);
+				~DetachKeyPairResult();
+				int getTotalCount()const;
+				std::vector<Result> getResults()const;
+				int getFailCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<Result> results_;
+				int failCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_DETACHKEYPAIRRESULT_H_

swas-open/include/alibabacloud/swas-open/model/ImportKeyPairRequest.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_IMPORTKEYPAIRREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_IMPORTKEYPAIRREQUEST_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 ImportKeyPairRequest : public RpcServiceRequest {
+public:
+	ImportKeyPairRequest();
+	~ImportKeyPairRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getPublicKeyBody() const;
+	void setPublicKeyBody(const std::string &publicKeyBody);
+	std::string getKeyPairName() const;
+	void setKeyPairName(const std::string &keyPairName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clientToken_;
+	std::string publicKeyBody_;
+	std::string keyPairName_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_IMPORTKEYPAIRREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ImportKeyPairResult.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_IMPORTKEYPAIRRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_IMPORTKEYPAIRRESULT_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 ImportKeyPairResult : public ServiceResult
+			{
+			public:
+
+
+				ImportKeyPairResult();
+				explicit ImportKeyPairResult(const std::string &payload);
+				~ImportKeyPairResult();
+				std::string getKeyPairName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string keyPairName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_IMPORTKEYPAIRRESULT_H_

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

@@ -34,12 +34,10 @@ public:
 	};
 	ListDisksRequest();
 	~ListDisksRequest();
-	std::string getDiskType() const;
-	void setDiskType(const std::string &diskType);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
-	std::string getInstanceId() const;
-	void setInstanceId(const std::string &instanceId);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	int getPageSize() const;
@@ -48,15 +46,20 @@ public:
 	void setDiskIds(const std::string &diskIds);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
+	std::string getDiskType() const;
+	void setDiskType(const std::string &diskType);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
 
 private:
-	std::string diskType_;
 	int pageNumber_;
-	std::string instanceId_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	int pageSize_;
 	std::string diskIds_;
 	std::vector<Tag> tag_;
+	std::string diskType_;
+	std::string instanceId_;
 };
 } // namespace Model
 } // namespace SWAS_OPEN

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

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					};
 					std::string status;
 					std::string category;
+					std::string resourceGroupId;
 					std::string instanceId;
 					std::string device;
 					int size;

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

@@ -36,6 +36,8 @@ public:
 	~ListInstancesRequest();
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	int getPageSize() const;
@@ -44,6 +46,8 @@ public:
 	void setPublicIpAddresses(const std::string &publicIpAddresses);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
+	std::string getInstanceName() const;
+	void setInstanceName(const std::string &instanceName);
 	std::string getInstanceIds() const;
 	void setInstanceIds(const std::string &instanceIds);
 	std::string getChargeType() const;
@@ -53,10 +57,12 @@ public:
 
 private:
 	int pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	int pageSize_;
 	std::string publicIpAddresses_;
 	std::vector<Tag> tag_;
+	std::string instanceName_;
 	std::string instanceIds_;
 	std::string chargeType_;
 	std::string status_;

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

@@ -65,20 +65,22 @@ namespace AlibabaCloud
 							std::string key;
 						};
 						std::string status;
-						std::string diskType;
-						std::vector<Disk::Tag1> diskTags;
 						std::string category;
+						std::string resourceGroupId;
 						std::string device;
 						int size;
-						std::string creationTime;
 						std::string diskChargeType;
-						std::string regionId;
 						std::string diskName;
-						std::string diskId;
 						std::string remark;
+						std::string diskType;
+						std::vector<Disk::Tag1> diskTags;
+						std::string creationTime;
+						std::string regionId;
+						std::string diskId;
 					};
 					std::string status;
 					std::string disableReason;
+					std::string resourceGroupId;
 					std::string instanceId;
 					std::string planId;
 					ResourceSpec resourceSpec;

swas-open/include/alibabacloud/swas-open/model/ListKeyPairsRequest.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_LISTKEYPAIRSREQUEST_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTKEYPAIRSREQUEST_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 ListKeyPairsRequest : public RpcServiceRequest {
+public:
+	ListKeyPairsRequest();
+	~ListKeyPairsRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getKeyPairName() const;
+	void setKeyPairName(const std::string &keyPairName);
+	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 clientToken_;
+	std::string keyPairName_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace SWAS_OPEN
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTKEYPAIRSREQUEST_H_

swas-open/include/alibabacloud/swas-open/model/ListKeyPairsResult.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_LISTKEYPAIRSRESULT_H_
+#define ALIBABACLOUD_SWAS_OPEN_MODEL_LISTKEYPAIRSRESULT_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 ListKeyPairsResult : public ServiceResult
+			{
+			public:
+				struct KeyPair
+				{
+					std::string keyPairName;
+					std::string publicKey;
+					std::string creationTime;
+					std::vector<std::string> instanceIds;
+				};
+
+
+				ListKeyPairsResult();
+				explicit ListKeyPairsResult(const std::string &payload);
+				~ListKeyPairsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<KeyPair> getKeyPairs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<KeyPair> keyPairs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SWAS_OPEN_MODEL_LISTKEYPAIRSRESULT_H_

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

@@ -38,6 +38,8 @@ public:
 	void setSnapshotIds(const std::string &snapshotIds);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	int getPageSize() const;
@@ -54,6 +56,7 @@ public:
 private:
 	std::string snapshotIds_;
 	int pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	int pageSize_;
 	std::string diskId_;

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

@@ -40,17 +40,18 @@ namespace AlibabaCloud
 						std::string key;
 					};
 					std::string status;
-					std::string snapshotId;
 					std::string progress;
+					std::string resourceGroupId;
 					std::string instanceId;
 					std::string rollbackTime;
+					std::string snapshotName;
+					std::string sourceDiskId;
+					std::string remark;
+					std::string snapshotId;
 					std::string creationTime;
 					std::string regionId;
 					std::string sourceDiskType;
-					std::string snapshotName;
 					std::vector<Snapshot::Tag> tags;
-					std::string sourceDiskId;
-					std::string remark;
 				};
 
 

swas-open/src/SWAS-OPENClient.cc

@@ -87,6 +87,42 @@ SWAS_OPENClient::AllocatePublicConnectionOutcomeCallable SWAS_OPENClient::alloca
 	return task->get_future();
 }
 
+SWAS_OPENClient::AttachKeyPairOutcome SWAS_OPENClient::attachKeyPair(const AttachKeyPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachKeyPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachKeyPairOutcome(AttachKeyPairResult(outcome.result()));
+	else
+		return AttachKeyPairOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::attachKeyPairAsync(const AttachKeyPairRequest& request, const AttachKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachKeyPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::AttachKeyPairOutcomeCallable SWAS_OPENClient::attachKeyPairCallable(const AttachKeyPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachKeyPairOutcome()>>(
+			[this, request]()
+			{
+			return this->attachKeyPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SWAS_OPENClient::CreateCommandOutcome SWAS_OPENClient::createCommand(const CreateCommandRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +339,42 @@ SWAS_OPENClient::CreateInstancesOutcomeCallable SWAS_OPENClient::createInstances
 	return task->get_future();
 }
 
+SWAS_OPENClient::CreateKeyPairOutcome SWAS_OPENClient::createKeyPair(const CreateKeyPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateKeyPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateKeyPairOutcome(CreateKeyPairResult(outcome.result()));
+	else
+		return CreateKeyPairOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::createKeyPairAsync(const CreateKeyPairRequest& request, const CreateKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createKeyPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::CreateKeyPairOutcomeCallable SWAS_OPENClient::createKeyPairCallable(const CreateKeyPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateKeyPairOutcome()>>(
+			[this, request]()
+			{
+			return this->createKeyPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SWAS_OPENClient::CreateSnapshotOutcome SWAS_OPENClient::createSnapshot(const CreateSnapshotRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +627,42 @@ SWAS_OPENClient::DeleteInstanceKeyPairOutcomeCallable SWAS_OPENClient::deleteIns
 	return task->get_future();
 }
 
+SWAS_OPENClient::DeleteKeyPairsOutcome SWAS_OPENClient::deleteKeyPairs(const DeleteKeyPairsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteKeyPairsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteKeyPairsOutcome(DeleteKeyPairsResult(outcome.result()));
+	else
+		return DeleteKeyPairsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::deleteKeyPairsAsync(const DeleteKeyPairsRequest& request, const DeleteKeyPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteKeyPairs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DeleteKeyPairsOutcomeCallable SWAS_OPENClient::deleteKeyPairsCallable(const DeleteKeyPairsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteKeyPairsOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteKeyPairs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SWAS_OPENClient::DeleteSnapshotOutcome SWAS_OPENClient::deleteSnapshot(const DeleteSnapshotRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1347,42 @@ SWAS_OPENClient::DescribeSecurityAgentStatusOutcomeCallable SWAS_OPENClient::des
 	return task->get_future();
 }
 
+SWAS_OPENClient::DetachKeyPairOutcome SWAS_OPENClient::detachKeyPair(const DetachKeyPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachKeyPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachKeyPairOutcome(DetachKeyPairResult(outcome.result()));
+	else
+		return DetachKeyPairOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::detachKeyPairAsync(const DetachKeyPairRequest& request, const DetachKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachKeyPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::DetachKeyPairOutcomeCallable SWAS_OPENClient::detachKeyPairCallable(const DetachKeyPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachKeyPairOutcome()>>(
+			[this, request]()
+			{
+			return this->detachKeyPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SWAS_OPENClient::DisableFirewallRuleOutcome SWAS_OPENClient::disableFirewallRule(const DisableFirewallRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1311,6 +1455,42 @@ SWAS_OPENClient::EnableFirewallRuleOutcomeCallable SWAS_OPENClient::enableFirewa
 	return task->get_future();
 }
 
+SWAS_OPENClient::ImportKeyPairOutcome SWAS_OPENClient::importKeyPair(const ImportKeyPairRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImportKeyPairOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImportKeyPairOutcome(ImportKeyPairResult(outcome.result()));
+	else
+		return ImportKeyPairOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::importKeyPairAsync(const ImportKeyPairRequest& request, const ImportKeyPairAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, importKeyPair(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ImportKeyPairOutcomeCallable SWAS_OPENClient::importKeyPairCallable(const ImportKeyPairRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImportKeyPairOutcome()>>(
+			[this, request]()
+			{
+			return this->importKeyPair(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SWAS_OPENClient::InstallCloudAssistantOutcome SWAS_OPENClient::installCloudAssistant(const InstallCloudAssistantRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +1887,42 @@ SWAS_OPENClient::ListInstancesTrafficPackagesOutcomeCallable SWAS_OPENClient::li
 	return task->get_future();
 }
 
+SWAS_OPENClient::ListKeyPairsOutcome SWAS_OPENClient::listKeyPairs(const ListKeyPairsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListKeyPairsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListKeyPairsOutcome(ListKeyPairsResult(outcome.result()));
+	else
+		return ListKeyPairsOutcome(outcome.error());
+}
+
+void SWAS_OPENClient::listKeyPairsAsync(const ListKeyPairsRequest& request, const ListKeyPairsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listKeyPairs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SWAS_OPENClient::ListKeyPairsOutcomeCallable SWAS_OPENClient::listKeyPairsCallable(const ListKeyPairsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListKeyPairsOutcome()>>(
+			[this, request]()
+			{
+			return this->listKeyPairs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SWAS_OPENClient::ListPlansOutcome SWAS_OPENClient::listPlans(const ListPlansRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

swas-open/src/model/AttachKeyPairRequest.cc

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

swas-open/src/model/AttachKeyPairResult.cc

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/AttachKeyPairResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::SWAS_OPEN;
+using namespace AlibabaCloud::SWAS_OPEN::Model;
+
+AttachKeyPairResult::AttachKeyPairResult() :
+	ServiceResult()
+{}
+
+AttachKeyPairResult::AttachKeyPairResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AttachKeyPairResult::~AttachKeyPairResult()
+{}
+
+void AttachKeyPairResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultsNode = value["Results"]["Result"];
+	for (auto valueResultsResult : allResultsNode)
+	{
+		Result resultsObject;
+		if(!valueResultsResult["Code"].isNull())
+			resultsObject.code = valueResultsResult["Code"].asString();
+		if(!valueResultsResult["Message"].isNull())
+			resultsObject.message = valueResultsResult["Message"].asString();
+		if(!valueResultsResult["Success"].isNull())
+			resultsObject.success = valueResultsResult["Success"].asString();
+		if(!valueResultsResult["InstanceId"].isNull())
+			resultsObject.instanceId = valueResultsResult["InstanceId"].asString();
+		results_.push_back(resultsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["FailCount"].isNull())
+		failCount_ = std::stoi(value["FailCount"].asString());
+
+}
+
+int AttachKeyPairResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<AttachKeyPairResult::Result> AttachKeyPairResult::getResults()const
+{
+	return results_;
+}
+
+int AttachKeyPairResult::getFailCount()const
+{
+	return failCount_;
+}
+

swas-open/src/model/CreateCommandRequest.cc

@@ -70,6 +70,15 @@ void CreateCommandRequest::setTimeout(long timeout) {
   setParameter(std::string("Timeout"), std::to_string(timeout));
 }
 
+std::string CreateCommandRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateCommandRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string CreateCommandRequest::getRegionId() const {
   return regionId_;
 }

swas-open/src/model/CreateCustomImageRequest.cc

@@ -61,6 +61,15 @@ void CreateCustomImageRequest::setDescription(const std::string &description) {
   setParameter(std::string("Description"), description);
 }
 
+std::string CreateCustomImageRequest::getResoureGroupId() const {
+  return resoureGroupId_;
+}
+
+void CreateCustomImageRequest::setResoureGroupId(const std::string &resoureGroupId) {
+  resoureGroupId_ = resoureGroupId;
+  setParameter(std::string("ResoureGroupId"), resoureGroupId);
+}
+
 std::string CreateCustomImageRequest::getPlatform() const {
   return platform_;
 }

swas-open/src/model/CreateKeyPairRequest.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/CreateKeyPairRequest.h>
+
+using AlibabaCloud::SWAS_OPEN::Model::CreateKeyPairRequest;
+
+CreateKeyPairRequest::CreateKeyPairRequest()
+    : RpcServiceRequest("swas-open", "2020-06-01", "CreateKeyPair") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateKeyPairRequest::~CreateKeyPairRequest() {}
+
+std::string CreateKeyPairRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateKeyPairRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateKeyPairRequest::getKeyPairName() const {
+  return keyPairName_;
+}
+
+void CreateKeyPairRequest::setKeyPairName(const std::string &keyPairName) {
+  keyPairName_ = keyPairName;
+  setParameter(std::string("KeyPairName"), keyPairName);
+}
+
+std::string CreateKeyPairRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateKeyPairRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

swas-open/src/model/CreateKeyPairResult.cc

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

swas-open/src/model/CreateSnapshotRequest.cc

@@ -43,6 +43,15 @@ void CreateSnapshotRequest::setSnapshotName(const std::string &snapshotName) {
   setParameter(std::string("SnapshotName"), snapshotName);
 }
 
+std::string CreateSnapshotRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateSnapshotRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string CreateSnapshotRequest::getRegionId() const {
   return regionId_;
 }

swas-open/src/model/DeleteKeyPairsRequest.cc

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

swas-open/src/model/DeleteKeyPairsResult.cc

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

swas-open/src/model/DescribeCommandsRequest.cc

@@ -52,6 +52,15 @@ void DescribeCommandsRequest::setPageNumber(const std::string &pageNumber) {
   setParameter(std::string("PageNumber"), pageNumber);
 }
 
+std::string DescribeCommandsRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeCommandsRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string DescribeCommandsRequest::getRegionId() const {
   return regionId_;
 }

swas-open/src/model/DescribeCommandsResult.cc

@@ -63,6 +63,8 @@ void DescribeCommandsResult::parse(const std::string &payload)
 			commandsObject.commandContent = valueCommandscommand["CommandContent"].asString();
 		if(!valueCommandscommand["EnableParameter"].isNull())
 			commandsObject.enableParameter = valueCommandscommand["EnableParameter"].asString() == "true";
+		if(!valueCommandscommand["ResourceGroupId"].isNull())
+			commandsObject.resourceGroupId = valueCommandscommand["ResourceGroupId"].asString();
 		auto allTagsNode = valueCommandscommand["Tags"]["tag"];
 		for (auto valueCommandscommandTagstag : allTagsNode)
 		{

swas-open/src/model/DetachKeyPairRequest.cc

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

swas-open/src/model/DetachKeyPairResult.cc

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DetachKeyPairResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::SWAS_OPEN;
+using namespace AlibabaCloud::SWAS_OPEN::Model;
+
+DetachKeyPairResult::DetachKeyPairResult() :
+	ServiceResult()
+{}
+
+DetachKeyPairResult::DetachKeyPairResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetachKeyPairResult::~DetachKeyPairResult()
+{}
+
+void DetachKeyPairResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultsNode = value["Results"]["Result"];
+	for (auto valueResultsResult : allResultsNode)
+	{
+		Result resultsObject;
+		if(!valueResultsResult["Code"].isNull())
+			resultsObject.code = valueResultsResult["Code"].asString();
+		if(!valueResultsResult["Message"].isNull())
+			resultsObject.message = valueResultsResult["Message"].asString();
+		if(!valueResultsResult["Success"].isNull())
+			resultsObject.success = valueResultsResult["Success"].asString();
+		if(!valueResultsResult["InstanceId"].isNull())
+			resultsObject.instanceId = valueResultsResult["InstanceId"].asString();
+		results_.push_back(resultsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["FailCount"].isNull())
+		failCount_ = std::stoi(value["FailCount"].asString());
+
+}
+
+int DetachKeyPairResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<DetachKeyPairResult::Result> DetachKeyPairResult::getResults()const
+{
+	return results_;
+}
+
+int DetachKeyPairResult::getFailCount()const
+{
+	return failCount_;
+}
+

swas-open/src/model/ImportKeyPairRequest.cc

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

swas-open/src/model/ImportKeyPairResult.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/ImportKeyPairResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::SWAS_OPEN;
+using namespace AlibabaCloud::SWAS_OPEN::Model;
+
+ImportKeyPairResult::ImportKeyPairResult() :
+	ServiceResult()
+{}
+
+ImportKeyPairResult::ImportKeyPairResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ImportKeyPairResult::~ImportKeyPairResult()
+{}
+
+void ImportKeyPairResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["KeyPairName"].isNull())
+		keyPairName_ = value["KeyPairName"].asString();
+
+}
+
+std::string ImportKeyPairResult::getKeyPairName()const
+{
+	return keyPairName_;
+}
+

swas-open/src/model/ListDisksRequest.cc

@@ -25,15 +25,6 @@ ListDisksRequest::ListDisksRequest()
 
 ListDisksRequest::~ListDisksRequest() {}
 
-std::string ListDisksRequest::getDiskType() const {
-  return diskType_;
-}
-
-void ListDisksRequest::setDiskType(const std::string &diskType) {
-  diskType_ = diskType;
-  setParameter(std::string("DiskType"), diskType);
-}
-
 int ListDisksRequest::getPageNumber() const {
   return pageNumber_;
 }
@@ -43,13 +34,13 @@ void ListDisksRequest::setPageNumber(int pageNumber) {
   setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-std::string ListDisksRequest::getInstanceId() const {
-  return instanceId_;
+std::string ListDisksRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-void ListDisksRequest::setInstanceId(const std::string &instanceId) {
-  instanceId_ = instanceId;
-  setParameter(std::string("InstanceId"), instanceId);
+void ListDisksRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
 std::string ListDisksRequest::getRegionId() const {
@@ -93,3 +84,21 @@ void ListDisksRequest::setTag(const std::vector<ListDisksRequest::Tag> &tag) {
   }
 }
 
+std::string ListDisksRequest::getDiskType() const {
+  return diskType_;
+}
+
+void ListDisksRequest::setDiskType(const std::string &diskType) {
+  diskType_ = diskType;
+  setParameter(std::string("DiskType"), diskType);
+}
+
+std::string ListDisksRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void ListDisksRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+

swas-open/src/model/ListDisksResult.cc

@@ -69,6 +69,8 @@ void ListDisksResult::parse(const std::string &payload)
 			disksObject.remark = valueDisksDisk["Remark"].asString();
 		if(!valueDisksDisk["InstanceName"].isNull())
 			disksObject.instanceName = valueDisksDisk["InstanceName"].asString();
+		if(!valueDisksDisk["ResourceGroupId"].isNull())
+			disksObject.resourceGroupId = valueDisksDisk["ResourceGroupId"].asString();
 		auto allTagsNode = valueDisksDisk["Tags"]["tag"];
 		for (auto valueDisksDiskTagstag : allTagsNode)
 		{

swas-open/src/model/ListInstancesRequest.cc

@@ -34,6 +34,15 @@ void ListInstancesRequest::setPageNumber(int pageNumber) {
   setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string ListInstancesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ListInstancesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string ListInstancesRequest::getRegionId() const {
   return regionId_;
 }
@@ -75,6 +84,15 @@ void ListInstancesRequest::setTag(const std::vector<ListInstancesRequest::Tag> &
   }
 }
 
+std::string ListInstancesRequest::getInstanceName() const {
+  return instanceName_;
+}
+
+void ListInstancesRequest::setInstanceName(const std::string &instanceName) {
+  instanceName_ = instanceName;
+  setParameter(std::string("InstanceName"), instanceName);
+}
+
 std::string ListInstancesRequest::getInstanceIds() const {
   return instanceIds_;
 }

swas-open/src/model/ListInstancesResult.cc

@@ -77,6 +77,8 @@ void ListInstancesResult::parse(const std::string &payload)
 			instancesObject.combinationInstanceId = valueInstancesInstance["CombinationInstanceId"].asString();
 		if(!valueInstancesInstance["Uuid"].isNull())
 			instancesObject.uuid = valueInstancesInstance["Uuid"].asString();
+		if(!valueInstancesInstance["ResourceGroupId"].isNull())
+			instancesObject.resourceGroupId = valueInstancesInstance["ResourceGroupId"].asString();
 		auto allTagsNode = valueInstancesInstance["Tags"]["tag"];
 		for (auto valueInstancesInstanceTagstag : allTagsNode)
 		{
@@ -113,6 +115,8 @@ void ListInstancesResult::parse(const std::string &payload)
 				disksObject.regionId = valueInstancesInstanceDisksdisk["RegionId"].asString();
 			if(!valueInstancesInstanceDisksdisk["Remark"].isNull())
 				disksObject.remark = valueInstancesInstanceDisksdisk["Remark"].asString();
+			if(!valueInstancesInstanceDisksdisk["ResourceGroupId"].isNull())
+				disksObject.resourceGroupId = valueInstancesInstanceDisksdisk["ResourceGroupId"].asString();
 			auto allDiskTagsNode = valueInstancesInstanceDisksdisk["DiskTags"]["tag"];
 			for (auto valueInstancesInstanceDisksdiskDiskTagstag : allDiskTagsNode)
 			{

swas-open/src/model/ListKeyPairsRequest.cc

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

swas-open/src/model/ListKeyPairsResult.cc

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ListKeyPairsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::SWAS_OPEN;
+using namespace AlibabaCloud::SWAS_OPEN::Model;
+
+ListKeyPairsResult::ListKeyPairsResult() :
+	ServiceResult()
+{}
+
+ListKeyPairsResult::ListKeyPairsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListKeyPairsResult::~ListKeyPairsResult()
+{}
+
+void ListKeyPairsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allKeyPairsNode = value["KeyPairs"]["KeyPair"];
+	for (auto valueKeyPairsKeyPair : allKeyPairsNode)
+	{
+		KeyPair keyPairsObject;
+		if(!valueKeyPairsKeyPair["CreationTime"].isNull())
+			keyPairsObject.creationTime = valueKeyPairsKeyPair["CreationTime"].asString();
+		if(!valueKeyPairsKeyPair["KeyPairName"].isNull())
+			keyPairsObject.keyPairName = valueKeyPairsKeyPair["KeyPairName"].asString();
+		if(!valueKeyPairsKeyPair["PublicKey"].isNull())
+			keyPairsObject.publicKey = valueKeyPairsKeyPair["PublicKey"].asString();
+		auto allInstanceIds = value["InstanceIds"]["InstanceId"];
+		for (auto value : allInstanceIds)
+			keyPairsObject.instanceIds.push_back(value.asString());
+		keyPairs_.push_back(keyPairsObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+
+}
+
+int ListKeyPairsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListKeyPairsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListKeyPairsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListKeyPairsResult::KeyPair> ListKeyPairsResult::getKeyPairs()const
+{
+	return keyPairs_;
+}
+

swas-open/src/model/ListSnapshotsRequest.cc

@@ -43,6 +43,15 @@ void ListSnapshotsRequest::setPageNumber(int pageNumber) {
   setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string ListSnapshotsRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ListSnapshotsRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string ListSnapshotsRequest::getRegionId() const {
   return regionId_;
 }

swas-open/src/model/ListSnapshotsResult.cc

@@ -65,6 +65,8 @@ void ListSnapshotsResult::parse(const std::string &payload)
 			snapshotsObject.instanceId = valueSnapshotsSnapshot["InstanceId"].asString();
 		if(!valueSnapshotsSnapshot["RollbackTime"].isNull())
 			snapshotsObject.rollbackTime = valueSnapshotsSnapshot["RollbackTime"].asString();
+		if(!valueSnapshotsSnapshot["ResourceGroupId"].isNull())
+			snapshotsObject.resourceGroupId = valueSnapshotsSnapshot["ResourceGroupId"].asString();
 		auto allTagsNode = valueSnapshotsSnapshot["Tags"]["tag"];
 		for (auto valueSnapshotsSnapshotTagstag : allTagsNode)
 		{