Add auto grouping apis.

VERSION

@@ -1 +1 @@
-1.36.2043
+1.36.2044

resourcemanager/CMakeLists.txt

@@ -41,6 +41,8 @@ set(resourcemanager_public_header_model
 	include/alibabacloud/resourcemanager/model/ChangeAccountEmailResult.h
 	include/alibabacloud/resourcemanager/model/CheckAccountDeleteRequest.h
 	include/alibabacloud/resourcemanager/model/CheckAccountDeleteResult.h
+	include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h
+	include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.h
 	include/alibabacloud/resourcemanager/model/CreateCloudAccountRequest.h
 	include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h
 	include/alibabacloud/resourcemanager/model/CreateControlPolicyRequest.h
@@ -63,6 +65,8 @@ set(resourcemanager_public_header_model
 	include/alibabacloud/resourcemanager/model/DeclineHandshakeResult.h
 	include/alibabacloud/resourcemanager/model/DeleteAccountRequest.h
 	include/alibabacloud/resourcemanager/model/DeleteAccountResult.h
+	include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h
+	include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.h
 	include/alibabacloud/resourcemanager/model/DeleteControlPolicyRequest.h
 	include/alibabacloud/resourcemanager/model/DeleteControlPolicyResult.h
 	include/alibabacloud/resourcemanager/model/DeleteFolderRequest.h
@@ -85,8 +89,16 @@ set(resourcemanager_public_header_model
 	include/alibabacloud/resourcemanager/model/DetachControlPolicyResult.h
 	include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h
 	include/alibabacloud/resourcemanager/model/DetachPolicyResult.h
+	include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h
+	include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.h
+	include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h
+	include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.h
 	include/alibabacloud/resourcemanager/model/DisableControlPolicyRequest.h
 	include/alibabacloud/resourcemanager/model/DisableControlPolicyResult.h
+	include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h
+	include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.h
+	include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h
+	include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.h
 	include/alibabacloud/resourcemanager/model/EnableControlPolicyRequest.h
 	include/alibabacloud/resourcemanager/model/EnableControlPolicyResult.h
 	include/alibabacloud/resourcemanager/model/EnableResourceDirectoryRequest.h
@@ -97,6 +109,10 @@ set(resourcemanager_public_header_model
 	include/alibabacloud/resourcemanager/model/GetAccountDeletionCheckResultResult.h
 	include/alibabacloud/resourcemanager/model/GetAccountDeletionStatusRequest.h
 	include/alibabacloud/resourcemanager/model/GetAccountDeletionStatusResult.h
+	include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h
+	include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h
+	include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h
+	include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.h
 	include/alibabacloud/resourcemanager/model/GetControlPolicyRequest.h
 	include/alibabacloud/resourcemanager/model/GetControlPolicyResult.h
 	include/alibabacloud/resourcemanager/model/GetControlPolicyEnablementStatusRequest.h
@@ -129,6 +145,10 @@ set(resourcemanager_public_header_model
 	include/alibabacloud/resourcemanager/model/ListAccountsForParentResult.h
 	include/alibabacloud/resourcemanager/model/ListAncestorsRequest.h
 	include/alibabacloud/resourcemanager/model/ListAncestorsResult.h
+	include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h
+	include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h
+	include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.h
+	include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h
 	include/alibabacloud/resourcemanager/model/ListControlPoliciesRequest.h
 	include/alibabacloud/resourcemanager/model/ListControlPoliciesResult.h
 	include/alibabacloud/resourcemanager/model/ListControlPolicyAttachmentsForTargetRequest.h
@@ -195,6 +215,12 @@ set(resourcemanager_public_header_model
 	include/alibabacloud/resourcemanager/model/UntagResourcesResult.h
 	include/alibabacloud/resourcemanager/model/UpdateAccountRequest.h
 	include/alibabacloud/resourcemanager/model/UpdateAccountResult.h
+	include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h
+	include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.h
+	include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h
+	include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.h
+	include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h
+	include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.h
 	include/alibabacloud/resourcemanager/model/UpdateControlPolicyRequest.h
 	include/alibabacloud/resourcemanager/model/UpdateControlPolicyResult.h
 	include/alibabacloud/resourcemanager/model/UpdateFolderRequest.h
@@ -226,6 +252,8 @@ set(resourcemanager_src
 	src/model/ChangeAccountEmailResult.cc
 	src/model/CheckAccountDeleteRequest.cc
 	src/model/CheckAccountDeleteResult.cc
+	src/model/CreateAutoGroupingRuleRequest.cc
+	src/model/CreateAutoGroupingRuleResult.cc
 	src/model/CreateCloudAccountRequest.cc
 	src/model/CreateCloudAccountResult.cc
 	src/model/CreateControlPolicyRequest.cc
@@ -248,6 +276,8 @@ set(resourcemanager_src
 	src/model/DeclineHandshakeResult.cc
 	src/model/DeleteAccountRequest.cc
 	src/model/DeleteAccountResult.cc
+	src/model/DeleteAutoGroupingRuleRequest.cc
+	src/model/DeleteAutoGroupingRuleResult.cc
 	src/model/DeleteControlPolicyRequest.cc
 	src/model/DeleteControlPolicyResult.cc
 	src/model/DeleteFolderRequest.cc
@@ -270,8 +300,16 @@ set(resourcemanager_src
 	src/model/DetachControlPolicyResult.cc
 	src/model/DetachPolicyRequest.cc
 	src/model/DetachPolicyResult.cc
+	src/model/DisableAssociatedTransferRequest.cc
+	src/model/DisableAssociatedTransferResult.cc
+	src/model/DisableAutoGroupingRequest.cc
+	src/model/DisableAutoGroupingResult.cc
 	src/model/DisableControlPolicyRequest.cc
 	src/model/DisableControlPolicyResult.cc
+	src/model/EnableAssociatedTransferRequest.cc
+	src/model/EnableAssociatedTransferResult.cc
+	src/model/EnableAutoGroupingRequest.cc
+	src/model/EnableAutoGroupingResult.cc
 	src/model/EnableControlPolicyRequest.cc
 	src/model/EnableControlPolicyResult.cc
 	src/model/EnableResourceDirectoryRequest.cc
@@ -282,6 +320,10 @@ set(resourcemanager_src
 	src/model/GetAccountDeletionCheckResultResult.cc
 	src/model/GetAccountDeletionStatusRequest.cc
 	src/model/GetAccountDeletionStatusResult.cc
+	src/model/GetAutoGroupingRuleRequest.cc
+	src/model/GetAutoGroupingRuleResult.cc
+	src/model/GetAutoGroupingStatusRequest.cc
+	src/model/GetAutoGroupingStatusResult.cc
 	src/model/GetControlPolicyRequest.cc
 	src/model/GetControlPolicyResult.cc
 	src/model/GetControlPolicyEnablementStatusRequest.cc
@@ -314,6 +356,10 @@ set(resourcemanager_src
 	src/model/ListAccountsForParentResult.cc
 	src/model/ListAncestorsRequest.cc
 	src/model/ListAncestorsResult.cc
+	src/model/ListAssociatedTransferSettingRequest.cc
+	src/model/ListAssociatedTransferSettingResult.cc
+	src/model/ListAutoGroupingRulesRequest.cc
+	src/model/ListAutoGroupingRulesResult.cc
 	src/model/ListControlPoliciesRequest.cc
 	src/model/ListControlPoliciesResult.cc
 	src/model/ListControlPolicyAttachmentsForTargetRequest.cc
@@ -380,6 +426,12 @@ set(resourcemanager_src
 	src/model/UntagResourcesResult.cc
 	src/model/UpdateAccountRequest.cc
 	src/model/UpdateAccountResult.cc
+	src/model/UpdateAssociatedTransferSettingRequest.cc
+	src/model/UpdateAssociatedTransferSettingResult.cc
+	src/model/UpdateAutoGroupingConfigRequest.cc
+	src/model/UpdateAutoGroupingConfigResult.cc
+	src/model/UpdateAutoGroupingRuleRequest.cc
+	src/model/UpdateAutoGroupingRuleResult.cc
 	src/model/UpdateControlPolicyRequest.cc
 	src/model/UpdateControlPolicyResult.cc
 	src/model/UpdateFolderRequest.cc

resourcemanager/include/alibabacloud/resourcemanager/ResourceManagerClient.h

@@ -42,6 +42,8 @@
 #include "model/ChangeAccountEmailResult.h"
 #include "model/CheckAccountDeleteRequest.h"
 #include "model/CheckAccountDeleteResult.h"
+#include "model/CreateAutoGroupingRuleRequest.h"
+#include "model/CreateAutoGroupingRuleResult.h"
 #include "model/CreateCloudAccountRequest.h"
 #include "model/CreateCloudAccountResult.h"
 #include "model/CreateControlPolicyRequest.h"
@@ -64,6 +66,8 @@
 #include "model/DeclineHandshakeResult.h"
 #include "model/DeleteAccountRequest.h"
 #include "model/DeleteAccountResult.h"
+#include "model/DeleteAutoGroupingRuleRequest.h"
+#include "model/DeleteAutoGroupingRuleResult.h"
 #include "model/DeleteControlPolicyRequest.h"
 #include "model/DeleteControlPolicyResult.h"
 #include "model/DeleteFolderRequest.h"
@@ -86,8 +90,16 @@
 #include "model/DetachControlPolicyResult.h"
 #include "model/DetachPolicyRequest.h"
 #include "model/DetachPolicyResult.h"
+#include "model/DisableAssociatedTransferRequest.h"
+#include "model/DisableAssociatedTransferResult.h"
+#include "model/DisableAutoGroupingRequest.h"
+#include "model/DisableAutoGroupingResult.h"
 #include "model/DisableControlPolicyRequest.h"
 #include "model/DisableControlPolicyResult.h"
+#include "model/EnableAssociatedTransferRequest.h"
+#include "model/EnableAssociatedTransferResult.h"
+#include "model/EnableAutoGroupingRequest.h"
+#include "model/EnableAutoGroupingResult.h"
 #include "model/EnableControlPolicyRequest.h"
 #include "model/EnableControlPolicyResult.h"
 #include "model/EnableResourceDirectoryRequest.h"
@@ -98,6 +110,10 @@
 #include "model/GetAccountDeletionCheckResultResult.h"
 #include "model/GetAccountDeletionStatusRequest.h"
 #include "model/GetAccountDeletionStatusResult.h"
+#include "model/GetAutoGroupingRuleRequest.h"
+#include "model/GetAutoGroupingRuleResult.h"
+#include "model/GetAutoGroupingStatusRequest.h"
+#include "model/GetAutoGroupingStatusResult.h"
 #include "model/GetControlPolicyRequest.h"
 #include "model/GetControlPolicyResult.h"
 #include "model/GetControlPolicyEnablementStatusRequest.h"
@@ -130,6 +146,10 @@
 #include "model/ListAccountsForParentResult.h"
 #include "model/ListAncestorsRequest.h"
 #include "model/ListAncestorsResult.h"
+#include "model/ListAssociatedTransferSettingRequest.h"
+#include "model/ListAssociatedTransferSettingResult.h"
+#include "model/ListAutoGroupingRulesRequest.h"
+#include "model/ListAutoGroupingRulesResult.h"
 #include "model/ListControlPoliciesRequest.h"
 #include "model/ListControlPoliciesResult.h"
 #include "model/ListControlPolicyAttachmentsForTargetRequest.h"
@@ -196,6 +216,12 @@
 #include "model/UntagResourcesResult.h"
 #include "model/UpdateAccountRequest.h"
 #include "model/UpdateAccountResult.h"
+#include "model/UpdateAssociatedTransferSettingRequest.h"
+#include "model/UpdateAssociatedTransferSettingResult.h"
+#include "model/UpdateAutoGroupingConfigRequest.h"
+#include "model/UpdateAutoGroupingConfigResult.h"
+#include "model/UpdateAutoGroupingRuleRequest.h"
+#include "model/UpdateAutoGroupingRuleResult.h"
 #include "model/UpdateControlPolicyRequest.h"
 #include "model/UpdateControlPolicyResult.h"
 #include "model/UpdateFolderRequest.h"
@@ -243,6 +269,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CheckAccountDeleteResult> CheckAccountDeleteOutcome;
 			typedef std::future<CheckAccountDeleteOutcome> CheckAccountDeleteOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::CheckAccountDeleteRequest&, const CheckAccountDeleteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckAccountDeleteAsyncHandler;
+			typedef Outcome<Error, Model::CreateAutoGroupingRuleResult> CreateAutoGroupingRuleOutcome;
+			typedef std::future<CreateAutoGroupingRuleOutcome> CreateAutoGroupingRuleOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::CreateAutoGroupingRuleRequest&, const CreateAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAutoGroupingRuleAsyncHandler;
 			typedef Outcome<Error, Model::CreateCloudAccountResult> CreateCloudAccountOutcome;
 			typedef std::future<CreateCloudAccountOutcome> CreateCloudAccountOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::CreateCloudAccountRequest&, const CreateCloudAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCloudAccountAsyncHandler;
@@ -276,6 +305,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteAccountResult> DeleteAccountOutcome;
 			typedef std::future<DeleteAccountOutcome> DeleteAccountOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::DeleteAccountRequest&, const DeleteAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccountAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAutoGroupingRuleResult> DeleteAutoGroupingRuleOutcome;
+			typedef std::future<DeleteAutoGroupingRuleOutcome> DeleteAutoGroupingRuleOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::DeleteAutoGroupingRuleRequest&, const DeleteAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAutoGroupingRuleAsyncHandler;
 			typedef Outcome<Error, Model::DeleteControlPolicyResult> DeleteControlPolicyOutcome;
 			typedef std::future<DeleteControlPolicyOutcome> DeleteControlPolicyOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::DeleteControlPolicyRequest&, const DeleteControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteControlPolicyAsyncHandler;
@@ -309,9 +341,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DetachPolicyResult> DetachPolicyOutcome;
 			typedef std::future<DetachPolicyOutcome> DetachPolicyOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::DetachPolicyRequest&, const DetachPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DisableAssociatedTransferResult> DisableAssociatedTransferOutcome;
+			typedef std::future<DisableAssociatedTransferOutcome> DisableAssociatedTransferOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::DisableAssociatedTransferRequest&, const DisableAssociatedTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableAssociatedTransferAsyncHandler;
+			typedef Outcome<Error, Model::DisableAutoGroupingResult> DisableAutoGroupingOutcome;
+			typedef std::future<DisableAutoGroupingOutcome> DisableAutoGroupingOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::DisableAutoGroupingRequest&, const DisableAutoGroupingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableAutoGroupingAsyncHandler;
 			typedef Outcome<Error, Model::DisableControlPolicyResult> DisableControlPolicyOutcome;
 			typedef std::future<DisableControlPolicyOutcome> DisableControlPolicyOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::DisableControlPolicyRequest&, const DisableControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableControlPolicyAsyncHandler;
+			typedef Outcome<Error, Model::EnableAssociatedTransferResult> EnableAssociatedTransferOutcome;
+			typedef std::future<EnableAssociatedTransferOutcome> EnableAssociatedTransferOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::EnableAssociatedTransferRequest&, const EnableAssociatedTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAssociatedTransferAsyncHandler;
+			typedef Outcome<Error, Model::EnableAutoGroupingResult> EnableAutoGroupingOutcome;
+			typedef std::future<EnableAutoGroupingOutcome> EnableAutoGroupingOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::EnableAutoGroupingRequest&, const EnableAutoGroupingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableAutoGroupingAsyncHandler;
 			typedef Outcome<Error, Model::EnableControlPolicyResult> EnableControlPolicyOutcome;
 			typedef std::future<EnableControlPolicyOutcome> EnableControlPolicyOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::EnableControlPolicyRequest&, const EnableControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableControlPolicyAsyncHandler;
@@ -327,6 +371,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetAccountDeletionStatusResult> GetAccountDeletionStatusOutcome;
 			typedef std::future<GetAccountDeletionStatusOutcome> GetAccountDeletionStatusOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::GetAccountDeletionStatusRequest&, const GetAccountDeletionStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAccountDeletionStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetAutoGroupingRuleResult> GetAutoGroupingRuleOutcome;
+			typedef std::future<GetAutoGroupingRuleOutcome> GetAutoGroupingRuleOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::GetAutoGroupingRuleRequest&, const GetAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAutoGroupingRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetAutoGroupingStatusResult> GetAutoGroupingStatusOutcome;
+			typedef std::future<GetAutoGroupingStatusOutcome> GetAutoGroupingStatusOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::GetAutoGroupingStatusRequest&, const GetAutoGroupingStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAutoGroupingStatusAsyncHandler;
 			typedef Outcome<Error, Model::GetControlPolicyResult> GetControlPolicyOutcome;
 			typedef std::future<GetControlPolicyOutcome> GetControlPolicyOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::GetControlPolicyRequest&, const GetControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetControlPolicyAsyncHandler;
@@ -375,6 +425,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListAncestorsResult> ListAncestorsOutcome;
 			typedef std::future<ListAncestorsOutcome> ListAncestorsOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::ListAncestorsRequest&, const ListAncestorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAncestorsAsyncHandler;
+			typedef Outcome<Error, Model::ListAssociatedTransferSettingResult> ListAssociatedTransferSettingOutcome;
+			typedef std::future<ListAssociatedTransferSettingOutcome> ListAssociatedTransferSettingOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::ListAssociatedTransferSettingRequest&, const ListAssociatedTransferSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAssociatedTransferSettingAsyncHandler;
+			typedef Outcome<Error, Model::ListAutoGroupingRulesResult> ListAutoGroupingRulesOutcome;
+			typedef std::future<ListAutoGroupingRulesOutcome> ListAutoGroupingRulesOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::ListAutoGroupingRulesRequest&, const ListAutoGroupingRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAutoGroupingRulesAsyncHandler;
 			typedef Outcome<Error, Model::ListControlPoliciesResult> ListControlPoliciesOutcome;
 			typedef std::future<ListControlPoliciesOutcome> ListControlPoliciesOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::ListControlPoliciesRequest&, const ListControlPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListControlPoliciesAsyncHandler;
@@ -474,6 +530,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateAccountResult> UpdateAccountOutcome;
 			typedef std::future<UpdateAccountOutcome> UpdateAccountOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAccountRequest&, const UpdateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAccountAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAssociatedTransferSettingResult> UpdateAssociatedTransferSettingOutcome;
+			typedef std::future<UpdateAssociatedTransferSettingOutcome> UpdateAssociatedTransferSettingOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAssociatedTransferSettingRequest&, const UpdateAssociatedTransferSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAssociatedTransferSettingAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAutoGroupingConfigResult> UpdateAutoGroupingConfigOutcome;
+			typedef std::future<UpdateAutoGroupingConfigOutcome> UpdateAutoGroupingConfigOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAutoGroupingConfigRequest&, const UpdateAutoGroupingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAutoGroupingConfigAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAutoGroupingRuleResult> UpdateAutoGroupingRuleOutcome;
+			typedef std::future<UpdateAutoGroupingRuleOutcome> UpdateAutoGroupingRuleOutcomeCallable;
+			typedef std::function<void(const ResourceManagerClient*, const Model::UpdateAutoGroupingRuleRequest&, const UpdateAutoGroupingRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAutoGroupingRuleAsyncHandler;
 			typedef Outcome<Error, Model::UpdateControlPolicyResult> UpdateControlPolicyOutcome;
 			typedef std::future<UpdateControlPolicyOutcome> UpdateControlPolicyOutcomeCallable;
 			typedef std::function<void(const ResourceManagerClient*, const Model::UpdateControlPolicyRequest&, const UpdateControlPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateControlPolicyAsyncHandler;
@@ -521,6 +586,9 @@ namespace AlibabaCloud
 			CheckAccountDeleteOutcome checkAccountDelete(const Model::CheckAccountDeleteRequest &request)const;
 			void checkAccountDeleteAsync(const Model::CheckAccountDeleteRequest& request, const CheckAccountDeleteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckAccountDeleteOutcomeCallable checkAccountDeleteCallable(const Model::CheckAccountDeleteRequest& request) const;
+			CreateAutoGroupingRuleOutcome createAutoGroupingRule(const Model::CreateAutoGroupingRuleRequest &request)const;
+			void createAutoGroupingRuleAsync(const Model::CreateAutoGroupingRuleRequest& request, const CreateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAutoGroupingRuleOutcomeCallable createAutoGroupingRuleCallable(const Model::CreateAutoGroupingRuleRequest& request) const;
 			CreateCloudAccountOutcome createCloudAccount(const Model::CreateCloudAccountRequest &request)const;
 			void createCloudAccountAsync(const Model::CreateCloudAccountRequest& request, const CreateCloudAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCloudAccountOutcomeCallable createCloudAccountCallable(const Model::CreateCloudAccountRequest& request) const;
@@ -554,6 +622,9 @@ namespace AlibabaCloud
 			DeleteAccountOutcome deleteAccount(const Model::DeleteAccountRequest &request)const;
 			void deleteAccountAsync(const Model::DeleteAccountRequest& request, const DeleteAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteAccountOutcomeCallable deleteAccountCallable(const Model::DeleteAccountRequest& request) const;
+			DeleteAutoGroupingRuleOutcome deleteAutoGroupingRule(const Model::DeleteAutoGroupingRuleRequest &request)const;
+			void deleteAutoGroupingRuleAsync(const Model::DeleteAutoGroupingRuleRequest& request, const DeleteAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAutoGroupingRuleOutcomeCallable deleteAutoGroupingRuleCallable(const Model::DeleteAutoGroupingRuleRequest& request) const;
 			DeleteControlPolicyOutcome deleteControlPolicy(const Model::DeleteControlPolicyRequest &request)const;
 			void deleteControlPolicyAsync(const Model::DeleteControlPolicyRequest& request, const DeleteControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteControlPolicyOutcomeCallable deleteControlPolicyCallable(const Model::DeleteControlPolicyRequest& request) const;
@@ -587,9 +658,21 @@ namespace AlibabaCloud
 			DetachPolicyOutcome detachPolicy(const Model::DetachPolicyRequest &request)const;
 			void detachPolicyAsync(const Model::DetachPolicyRequest& request, const DetachPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetachPolicyOutcomeCallable detachPolicyCallable(const Model::DetachPolicyRequest& request) const;
+			DisableAssociatedTransferOutcome disableAssociatedTransfer(const Model::DisableAssociatedTransferRequest &request)const;
+			void disableAssociatedTransferAsync(const Model::DisableAssociatedTransferRequest& request, const DisableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableAssociatedTransferOutcomeCallable disableAssociatedTransferCallable(const Model::DisableAssociatedTransferRequest& request) const;
+			DisableAutoGroupingOutcome disableAutoGrouping(const Model::DisableAutoGroupingRequest &request)const;
+			void disableAutoGroupingAsync(const Model::DisableAutoGroupingRequest& request, const DisableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableAutoGroupingOutcomeCallable disableAutoGroupingCallable(const Model::DisableAutoGroupingRequest& request) const;
 			DisableControlPolicyOutcome disableControlPolicy(const Model::DisableControlPolicyRequest &request)const;
 			void disableControlPolicyAsync(const Model::DisableControlPolicyRequest& request, const DisableControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DisableControlPolicyOutcomeCallable disableControlPolicyCallable(const Model::DisableControlPolicyRequest& request) const;
+			EnableAssociatedTransferOutcome enableAssociatedTransfer(const Model::EnableAssociatedTransferRequest &request)const;
+			void enableAssociatedTransferAsync(const Model::EnableAssociatedTransferRequest& request, const EnableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableAssociatedTransferOutcomeCallable enableAssociatedTransferCallable(const Model::EnableAssociatedTransferRequest& request) const;
+			EnableAutoGroupingOutcome enableAutoGrouping(const Model::EnableAutoGroupingRequest &request)const;
+			void enableAutoGroupingAsync(const Model::EnableAutoGroupingRequest& request, const EnableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableAutoGroupingOutcomeCallable enableAutoGroupingCallable(const Model::EnableAutoGroupingRequest& request) const;
 			EnableControlPolicyOutcome enableControlPolicy(const Model::EnableControlPolicyRequest &request)const;
 			void enableControlPolicyAsync(const Model::EnableControlPolicyRequest& request, const EnableControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnableControlPolicyOutcomeCallable enableControlPolicyCallable(const Model::EnableControlPolicyRequest& request) const;
@@ -605,6 +688,12 @@ namespace AlibabaCloud
 			GetAccountDeletionStatusOutcome getAccountDeletionStatus(const Model::GetAccountDeletionStatusRequest &request)const;
 			void getAccountDeletionStatusAsync(const Model::GetAccountDeletionStatusRequest& request, const GetAccountDeletionStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAccountDeletionStatusOutcomeCallable getAccountDeletionStatusCallable(const Model::GetAccountDeletionStatusRequest& request) const;
+			GetAutoGroupingRuleOutcome getAutoGroupingRule(const Model::GetAutoGroupingRuleRequest &request)const;
+			void getAutoGroupingRuleAsync(const Model::GetAutoGroupingRuleRequest& request, const GetAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAutoGroupingRuleOutcomeCallable getAutoGroupingRuleCallable(const Model::GetAutoGroupingRuleRequest& request) const;
+			GetAutoGroupingStatusOutcome getAutoGroupingStatus(const Model::GetAutoGroupingStatusRequest &request)const;
+			void getAutoGroupingStatusAsync(const Model::GetAutoGroupingStatusRequest& request, const GetAutoGroupingStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAutoGroupingStatusOutcomeCallable getAutoGroupingStatusCallable(const Model::GetAutoGroupingStatusRequest& request) const;
 			GetControlPolicyOutcome getControlPolicy(const Model::GetControlPolicyRequest &request)const;
 			void getControlPolicyAsync(const Model::GetControlPolicyRequest& request, const GetControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetControlPolicyOutcomeCallable getControlPolicyCallable(const Model::GetControlPolicyRequest& request) const;
@@ -653,6 +742,12 @@ namespace AlibabaCloud
 			ListAncestorsOutcome listAncestors(const Model::ListAncestorsRequest &request)const;
 			void listAncestorsAsync(const Model::ListAncestorsRequest& request, const ListAncestorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAncestorsOutcomeCallable listAncestorsCallable(const Model::ListAncestorsRequest& request) const;
+			ListAssociatedTransferSettingOutcome listAssociatedTransferSetting(const Model::ListAssociatedTransferSettingRequest &request)const;
+			void listAssociatedTransferSettingAsync(const Model::ListAssociatedTransferSettingRequest& request, const ListAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAssociatedTransferSettingOutcomeCallable listAssociatedTransferSettingCallable(const Model::ListAssociatedTransferSettingRequest& request) const;
+			ListAutoGroupingRulesOutcome listAutoGroupingRules(const Model::ListAutoGroupingRulesRequest &request)const;
+			void listAutoGroupingRulesAsync(const Model::ListAutoGroupingRulesRequest& request, const ListAutoGroupingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAutoGroupingRulesOutcomeCallable listAutoGroupingRulesCallable(const Model::ListAutoGroupingRulesRequest& request) const;
 			ListControlPoliciesOutcome listControlPolicies(const Model::ListControlPoliciesRequest &request)const;
 			void listControlPoliciesAsync(const Model::ListControlPoliciesRequest& request, const ListControlPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListControlPoliciesOutcomeCallable listControlPoliciesCallable(const Model::ListControlPoliciesRequest& request) const;
@@ -752,6 +847,15 @@ namespace AlibabaCloud
 			UpdateAccountOutcome updateAccount(const Model::UpdateAccountRequest &request)const;
 			void updateAccountAsync(const Model::UpdateAccountRequest& request, const UpdateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateAccountOutcomeCallable updateAccountCallable(const Model::UpdateAccountRequest& request) const;
+			UpdateAssociatedTransferSettingOutcome updateAssociatedTransferSetting(const Model::UpdateAssociatedTransferSettingRequest &request)const;
+			void updateAssociatedTransferSettingAsync(const Model::UpdateAssociatedTransferSettingRequest& request, const UpdateAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAssociatedTransferSettingOutcomeCallable updateAssociatedTransferSettingCallable(const Model::UpdateAssociatedTransferSettingRequest& request) const;
+			UpdateAutoGroupingConfigOutcome updateAutoGroupingConfig(const Model::UpdateAutoGroupingConfigRequest &request)const;
+			void updateAutoGroupingConfigAsync(const Model::UpdateAutoGroupingConfigRequest& request, const UpdateAutoGroupingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAutoGroupingConfigOutcomeCallable updateAutoGroupingConfigCallable(const Model::UpdateAutoGroupingConfigRequest& request) const;
+			UpdateAutoGroupingRuleOutcome updateAutoGroupingRule(const Model::UpdateAutoGroupingRuleRequest &request)const;
+			void updateAutoGroupingRuleAsync(const Model::UpdateAutoGroupingRuleRequest& request, const UpdateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAutoGroupingRuleOutcomeCallable updateAutoGroupingRuleCallable(const Model::UpdateAutoGroupingRuleRequest& request) const;
 			UpdateControlPolicyOutcome updateControlPolicy(const Model::UpdateControlPolicyRequest &request)const;
 			void updateControlPolicyAsync(const Model::UpdateControlPolicyRequest& request, const UpdateControlPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateControlPolicyOutcomeCallable updateControlPolicyCallable(const Model::UpdateControlPolicyRequest& request) const;

resourcemanager/include/alibabacloud/resourcemanager/model/AttachPolicyRequest.h

@@ -30,21 +30,21 @@ class ALIBABACLOUD_RESOURCEMANAGER_EXPORT AttachPolicyRequest : public RpcServic
 public:
 	AttachPolicyRequest();
 	~AttachPolicyRequest();
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getPolicyType() const;
 	void setPolicyType(const std::string &policyType);
 	std::string getPrincipalType() const;
 	void setPrincipalType(const std::string &principalType);
-	std::string getResourceGroupId() const;
-	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getPolicyName() const;
 	void setPolicyName(const std::string &policyName);
 	std::string getPrincipalName() const;
 	void setPrincipalName(const std::string &principalName);
 
 private:
+	std::string resourceGroupId_;
 	std::string policyType_;
 	std::string principalType_;
-	std::string resourceGroupId_;
 	std::string policyName_;
 	std::string principalName_;
 };

resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleRequest.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_
+
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceManager {
+namespace Model {
+class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateAutoGroupingRuleRequest : public RpcServiceRequest {
+public:
+	struct RuleContents {
+		std::string targetResourceGroupCondition;
+		std::string autoGroupingScopeCondition;
+	};
+	CreateAutoGroupingRuleRequest();
+	~CreateAutoGroupingRuleRequest();
+	std::string getRuleDesc() const;
+	void setRuleDesc(const std::string &ruleDesc);
+	std::string getResourceTypesScope() const;
+	void setResourceTypesScope(const std::string &resourceTypesScope);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getExcludeResourceGroupIdsScope() const;
+	void setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope);
+	std::string getRegionIdsScope() const;
+	void setRegionIdsScope(const std::string &regionIdsScope);
+	std::string getResourceIdsScope() const;
+	void setResourceIdsScope(const std::string &resourceIdsScope);
+	std::vector<RuleContents> getRuleContents() const;
+	void setRuleContents(const std::vector<RuleContents> &ruleContents);
+	std::string getExcludeResourceTypesScope() const;
+	void setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope);
+	std::string getRuleType() const;
+	void setRuleType(const std::string &ruleType);
+	std::string getResourceGroupIdsScope() const;
+	void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope);
+	std::string getExcludeRegionIdsScope() const;
+	void setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope);
+	std::string getExcludeResourceIdsScope() const;
+	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+
+private:
+	std::string ruleDesc_;
+	std::string resourceTypesScope_;
+	std::string ruleName_;
+	std::string excludeResourceGroupIdsScope_;
+	std::string regionIdsScope_;
+	std::string resourceIdsScope_;
+	std::vector<RuleContents> ruleContents_;
+	std::string excludeResourceTypesScope_;
+	std::string ruleType_;
+	std::string resourceGroupIdsScope_;
+	std::string excludeRegionIdsScope_;
+	std::string excludeResourceIdsScope_;
+};
+} // namespace Model
+} // namespace ResourceManager
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULEREQUEST_H_

resourcemanager/include/alibabacloud/resourcemanager/model/CreateAutoGroupingRuleResult.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_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULERESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateAutoGroupingRuleResult : public ServiceResult
+			{
+			public:
+
+
+				CreateAutoGroupingRuleResult();
+				explicit CreateAutoGroupingRuleResult(const std::string &payload);
+				~CreateAutoGroupingRuleResult();
+				std::string getRuleId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string ruleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_CREATEAUTOGROUPINGRULERESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/CreateCloudAccountResult.h

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 					std::string status;
 					std::string joinMethod;
 					std::string modifyTime;
-					std::string type;
 					std::string resourceDirectoryId;
+					std::string type;
 					std::string accountId;
 					std::string displayName;
 					std::string folderId;

resourcemanager/include/alibabacloud/resourcemanager/model/CreateResourceGroupRequest.h

@@ -28,16 +28,23 @@ namespace ResourceManager {
 namespace Model {
 class ALIBABACLOUD_RESOURCEMANAGER_EXPORT CreateResourceGroupRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateResourceGroupRequest();
 	~CreateResourceGroupRequest();
 	std::string getDisplayName() const;
 	void setDisplayName(const std::string &displayName);
 	std::string getName() const;
 	void setName(const std::string &name);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 
 private:
 	std::string displayName_;
 	std::string name_;
+	std::vector<Tag> tag_;
 };
 } // namespace Model
 } // namespace ResourceManager

resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/DeleteAutoGroupingRuleResult.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_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULERESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DeleteAutoGroupingRuleResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteAutoGroupingRuleResult();
+				explicit DeleteAutoGroupingRuleResult(const std::string &payload);
+				~DeleteAutoGroupingRuleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DELETEAUTOGROUPINGRULERESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/DetachPolicyRequest.h

@@ -30,21 +30,21 @@ class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DetachPolicyRequest : public RpcServic
 public:
 	DetachPolicyRequest();
 	~DetachPolicyRequest();
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getPolicyType() const;
 	void setPolicyType(const std::string &policyType);
 	std::string getPrincipalType() const;
 	void setPrincipalType(const std::string &principalType);
-	std::string getResourceGroupId() const;
-	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getPolicyName() const;
 	void setPolicyName(const std::string &policyName);
 	std::string getPrincipalName() const;
 	void setPrincipalName(const std::string &principalName);
 
 private:
+	std::string resourceGroupId_;
 	std::string policyType_;
 	std::string principalType_;
-	std::string resourceGroupId_;
 	std::string policyName_;
 	std::string principalName_;
 };

resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/DisableAssociatedTransferResult.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_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DisableAssociatedTransferResult : public ServiceResult
+			{
+			public:
+
+
+				DisableAssociatedTransferResult();
+				explicit DisableAssociatedTransferResult(const std::string &payload);
+				~DisableAssociatedTransferResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEASSOCIATEDTRANSFERRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/DisableAutoGroupingResult.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_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT DisableAutoGroupingResult : public ServiceResult
+			{
+			public:
+
+
+				DisableAutoGroupingResult();
+				explicit DisableAutoGroupingResult(const std::string &payload);
+				~DisableAutoGroupingResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_DISABLEAUTOGROUPINGRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/EnableAssociatedTransferResult.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_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT EnableAssociatedTransferResult : public ServiceResult
+			{
+			public:
+
+
+				EnableAssociatedTransferResult();
+				explicit EnableAssociatedTransferResult(const std::string &payload);
+				~EnableAssociatedTransferResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEASSOCIATEDTRANSFERRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/EnableAutoGroupingResult.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_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT EnableAutoGroupingResult : public ServiceResult
+			{
+			public:
+
+
+				EnableAutoGroupingResult();
+				explicit EnableAutoGroupingResult(const std::string &payload);
+				~EnableAutoGroupingResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_ENABLEAUTOGROUPINGRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingRuleResult : public ServiceResult
+			{
+			public:
+				struct Rule
+				{
+					struct RuleContent
+					{
+						std::string autoGroupingScopeCondition;
+						std::string ruleContentId;
+						std::string targetResourceGroupCondition;
+					};
+					std::string modifyTime;
+					std::string excludeResourceGroupIdsScope;
+					std::string excludeResourceIdsScope;
+					std::string excludeResourceTypesScope;
+					std::string resourceIdsScope;
+					std::vector<RuleContent> ruleContents;
+					std::string createTime;
+					std::string ruleId;
+					std::string ruleType;
+					std::string excludeRegionIdsScope;
+					std::string regionIdsScope;
+					std::string resourceGroupIdsScope;
+					std::string ruleDesc;
+					std::string resourceTypesScope;
+					std::string ruleName;
+				};
+
+
+				GetAutoGroupingRuleResult();
+				explicit GetAutoGroupingRuleResult(const std::string &payload);
+				~GetAutoGroupingRuleResult();
+				Rule getRule()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Rule rule_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGRULERESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/GetAutoGroupingStatusResult.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_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT GetAutoGroupingStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetAutoGroupingStatusResult();
+				explicit GetAutoGroupingStatusResult(const std::string &payload);
+				~GetAutoGroupingStatusResult();
+				std::string getEnableStatus()const;
+				bool getEnableExistedResourcesTransfer()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string enableStatus_;
+				bool enableExistedResourcesTransfer_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_GETAUTOGROUPINGSTATUSRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/GetPolicyResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct Policy
 				{
-					std::string updateDate;
 					std::string policyType;
+					std::string updateDate;
 					std::string description;
 					int attachmentCount;
 					std::string defaultVersion;

resourcemanager/include/alibabacloud/resourcemanager/model/GetResourceDirectoryResult.h

@@ -38,9 +38,9 @@ namespace AlibabaCloud
 					std::string resourceDirectoryId;
 					std::string scpStatus;
 					std::string memberDeletionStatus;
-					std::string rootFolderId;
 					std::string createTime;
 					std::string masterAccountName;
+					std::string rootFolderId;
 					std::string controlPolicyStatus;
 					std::string masterAccountId;
 				};

resourcemanager/include/alibabacloud/resourcemanager/model/GetRoleResult.h

@@ -36,11 +36,11 @@ namespace AlibabaCloud
 				{
 					struct LatestDeletionTask
 					{
-						std::string deletionTaskId;
 						std::string createDate;
+						std::string deletionTaskId;
 					};
-					std::string updateDate;
 					long maxSessionDuration;
+					std::string updateDate;
 					std::string roleName;
 					std::string description;
 					std::string assumeRolePolicyDocument;

resourcemanager/include/alibabacloud/resourcemanager/model/InitResourceDirectoryResult.h

@@ -35,9 +35,9 @@ namespace AlibabaCloud
 				struct ResourceDirectory
 				{
 					std::string resourceDirectoryId;
-					std::string rootFolderId;
 					std::string createTime;
 					std::string masterAccountName;
+					std::string rootFolderId;
 					std::string masterAccountId;
 				};
 

resourcemanager/include/alibabacloud/resourcemanager/model/ListAccountsForParentRequest.h

@@ -34,26 +34,26 @@ public:
 	};
 	ListAccountsForParentRequest();
 	~ListAccountsForParentRequest();
-	std::string getQueryKeyword() const;
-	void setQueryKeyword(const std::string &queryKeyword);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
-	std::string getParentFolderId() const;
-	void setParentFolderId(const std::string &parentFolderId);
-	bool getIncludeTags() const;
-	void setIncludeTags(bool includeTags);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
+	std::string getQueryKeyword() const;
+	void setQueryKeyword(const std::string &queryKeyword);
+	std::string getParentFolderId() const;
+	void setParentFolderId(const std::string &parentFolderId);
+	bool getIncludeTags() const;
+	void setIncludeTags(bool includeTags);
 
 private:
-	std::string queryKeyword_;
 	int pageNumber_;
-	std::string parentFolderId_;
-	bool includeTags_;
 	int pageSize_;
 	std::vector<Tag> tag_;
+	std::string queryKeyword_;
+	std::string parentFolderId_;
+	bool includeTags_;
 };
 } // namespace Model
 } // namespace ResourceManager

resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingRequest.h

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

resourcemanager/include/alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAssociatedTransferSettingResult : public ServiceResult
+			{
+			public:
+				struct AssociatedTransferSetting
+				{
+					struct RuleSetting
+					{
+						std::string status;
+						std::string triggerType;
+						std::string associatedService;
+						std::string masterResourceType;
+						std::string ruleId;
+						std::string associatedResourceType;
+						std::string masterService;
+					};
+					std::string status;
+					std::string enablePartialRule;
+					std::string accountId;
+					std::string enableExistingResourcesTransfer;
+					std::vector<RuleSetting> ruleSettings;
+				};
+
+
+				ListAssociatedTransferSettingResult();
+				explicit ListAssociatedTransferSettingResult(const std::string &payload);
+				~ListAssociatedTransferSettingResult();
+				AssociatedTransferSetting getAssociatedTransferSetting()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				AssociatedTransferSetting associatedTransferSetting_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTASSOCIATEDTRANSFERSETTINGRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesRequest.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_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_
+
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceManager {
+namespace Model {
+class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAutoGroupingRulesRequest : public RpcServiceRequest {
+public:
+	ListAutoGroupingRulesRequest();
+	~ListAutoGroupingRulesRequest();
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRuleType() const;
+	void setRuleType(const std::string &ruleType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getRuleId() const;
+	void setRuleId(const std::string &ruleId);
+
+private:
+	std::string ruleName_;
+	std::string nextToken_;
+	std::string ruleType_;
+	int maxResults_;
+	std::string ruleId_;
+};
+} // namespace Model
+} // namespace ResourceManager
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESREQUEST_H_

resourcemanager/include/alibabacloud/resourcemanager/model/ListAutoGroupingRulesResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT ListAutoGroupingRulesResult : public ServiceResult
+			{
+			public:
+				struct Rule
+				{
+					struct RuleContent
+					{
+						std::string autoGroupingScopeCondition;
+						std::string ruleContentId;
+						std::string targetResourceGroupCondition;
+					};
+					std::string modifyTime;
+					std::string excludeResourceGroupIdsScope;
+					std::string excludeResourceIdsScope;
+					std::string excludeResourceTypesScope;
+					std::string resourceIdsScope;
+					std::vector<Rule::RuleContent> ruleContents;
+					std::string createTime;
+					std::string ruleId;
+					std::string ruleType;
+					std::string excludeRegionIdsScope;
+					std::string regionIdsScope;
+					std::string resourceGroupIdsScope;
+					std::string ruleDesc;
+					std::string resourceTypesScope;
+					std::string ruleName;
+				};
+
+
+				ListAutoGroupingRulesResult();
+				explicit ListAutoGroupingRulesResult(const std::string &payload);
+				~ListAutoGroupingRulesResult();
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<Rule> getRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<Rule> rules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_LISTAUTOGROUPINGRULESRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/ListPoliciesResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct Policy
 				{
-					std::string updateDate;
 					std::string policyType;
+					std::string updateDate;
 					std::string description;
 					int attachmentCount;
 					std::string defaultVersion;

resourcemanager/include/alibabacloud/resourcemanager/model/ListRolesResult.h

@@ -36,11 +36,11 @@ namespace AlibabaCloud
 				{
 					struct LatestDeletionTask
 					{
-						std::string deletionTaskId;
 						std::string createDate;
+						std::string deletionTaskId;
 					};
-					std::string updateDate;
 					long maxSessionDuration;
+					std::string updateDate;
 					std::string roleName;
 					std::string description;
 					LatestDeletionTask latestDeletionTask;

resourcemanager/include/alibabacloud/resourcemanager/model/ListTagResourcesRequest.h

@@ -34,23 +34,23 @@ public:
 	};
 	ListTagResourcesRequest();
 	~ListTagResourcesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::vector<std::string> getResourceId() const;
 	void setResourceId(const std::vector<std::string> &resourceId);
 	std::string getResourceType() const;
 	void setResourceType(const std::string &resourceType);
-	std::string getNextToken() const;
-	void setNextToken(const std::string &nextToken);
 	int getMaxResults() const;
 	void setMaxResults(int maxResults);
-	std::vector<Tag> getTag() const;
-	void setTag(const std::vector<Tag> &tag);
 
 private:
+	std::string nextToken_;
+	std::vector<Tag> tag_;
 	std::vector<std::string> resourceId_;
 	std::string resourceType_;
-	std::string nextToken_;
 	int maxResults_;
-	std::vector<Tag> tag_;
 };
 } // namespace Model
 } // namespace ResourceManager

resourcemanager/include/alibabacloud/resourcemanager/model/PromoteResourceAccountResult.h

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 					std::string status;
 					std::string joinMethod;
 					std::string modifyTime;
-					std::string type;
 					std::string resourceDirectoryId;
+					std::string type;
 					std::string accountId;
 					std::string displayName;
 					std::string joinTime;

resourcemanager/include/alibabacloud/resourcemanager/model/ResendCreateCloudAccountEmailResult.h

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 					std::string status;
 					std::string joinMethod;
 					std::string modifyTime;
-					std::string type;
 					std::string resourceDirectoryId;
+					std::string type;
 					std::string accountId;
 					std::string displayName;
 					std::string joinTime;

resourcemanager/include/alibabacloud/resourcemanager/model/ResendPromoteResourceAccountEmailResult.h

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 					std::string status;
 					std::string joinMethod;
 					std::string modifyTime;
-					std::string type;
 					std::string resourceDirectoryId;
+					std::string type;
 					std::string accountId;
 					std::string displayName;
 					std::string joinTime;

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingRequest.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_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_
+
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceManager {
+namespace Model {
+class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAssociatedTransferSettingRequest : public RpcServiceRequest {
+public:
+	struct RuleSettings {
+		std::string associatedService;
+		std::string masterService;
+		std::string masterResourceType;
+		std::string associatedResourceType;
+		std::string ruleId;
+		std::string status;
+	};
+	UpdateAssociatedTransferSettingRequest();
+	~UpdateAssociatedTransferSettingRequest();
+	std::vector<RuleSettings> getRuleSettings() const;
+	void setRuleSettings(const std::vector<RuleSettings> &ruleSettings);
+	std::string getEnableExistingResourcesTransfer() const;
+	void setEnableExistingResourcesTransfer(const std::string &enableExistingResourcesTransfer);
+
+private:
+	std::vector<RuleSettings> ruleSettings_;
+	std::string enableExistingResourcesTransfer_;
+};
+} // namespace Model
+} // namespace ResourceManager
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGREQUEST_H_

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAssociatedTransferSettingResult.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_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAssociatedTransferSettingResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateAssociatedTransferSettingResult();
+				explicit UpdateAssociatedTransferSettingResult(const std::string &payload);
+				~UpdateAssociatedTransferSettingResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEASSOCIATEDTRANSFERSETTINGRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_
+
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceManager {
+namespace Model {
+class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingConfigRequest : public RpcServiceRequest {
+public:
+	UpdateAutoGroupingConfigRequest();
+	~UpdateAutoGroupingConfigRequest();
+	bool getEnableExistingResourcesTransfer() const;
+	void setEnableExistingResourcesTransfer(bool enableExistingResourcesTransfer);
+
+private:
+	bool enableExistingResourcesTransfer_;
+};
+} // namespace Model
+} // namespace ResourceManager
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGREQUEST_H_

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingConfigResult.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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGRESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingConfigResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateAutoGroupingConfigResult();
+				explicit UpdateAutoGroupingConfigResult(const std::string &payload);
+				~UpdateAutoGroupingConfigResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGCONFIGRESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleRequest.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_
+
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceManager {
+namespace Model {
+class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingRuleRequest : public RpcServiceRequest {
+public:
+	struct RuleContents {
+		std::string ruleContentId;
+		std::string targetResourceGroupCondition;
+		std::string autoGroupingScopeCondition;
+	};
+	UpdateAutoGroupingRuleRequest();
+	~UpdateAutoGroupingRuleRequest();
+	std::string getRuleDesc() const;
+	void setRuleDesc(const std::string &ruleDesc);
+	std::string getResourceTypesScope() const;
+	void setResourceTypesScope(const std::string &resourceTypesScope);
+	std::string getRuleName() const;
+	void setRuleName(const std::string &ruleName);
+	std::string getExcludeResourceGroupIdsScope() const;
+	void setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope);
+	std::string getRegionIdsScope() const;
+	void setRegionIdsScope(const std::string &regionIdsScope);
+	std::string getResourceIdsScope() const;
+	void setResourceIdsScope(const std::string &resourceIdsScope);
+	std::vector<RuleContents> getRuleContents() const;
+	void setRuleContents(const std::vector<RuleContents> &ruleContents);
+	std::string getExcludeResourceTypesScope() const;
+	void setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope);
+	std::string getResourceGroupIdsScope() const;
+	void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope);
+	std::string getExcludeRegionIdsScope() const;
+	void setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope);
+	std::string getExcludeResourceIdsScope() const;
+	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+	std::string getRuleId() const;
+	void setRuleId(const std::string &ruleId);
+
+private:
+	std::string ruleDesc_;
+	std::string resourceTypesScope_;
+	std::string ruleName_;
+	std::string excludeResourceGroupIdsScope_;
+	std::string regionIdsScope_;
+	std::string resourceIdsScope_;
+	std::vector<RuleContents> ruleContents_;
+	std::string excludeResourceTypesScope_;
+	std::string resourceGroupIdsScope_;
+	std::string excludeRegionIdsScope_;
+	std::string excludeResourceIdsScope_;
+	std::string ruleId_;
+};
+} // namespace Model
+} // namespace ResourceManager
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULEREQUEST_H_

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateAutoGroupingRuleResult.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_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULERESULT_H_
+#define ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcemanager/ResourceManagerExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceManager
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCEMANAGER_EXPORT UpdateAutoGroupingRuleResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateAutoGroupingRuleResult();
+				explicit UpdateAutoGroupingRuleResult(const std::string &payload);
+				~UpdateAutoGroupingRuleResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCEMANAGER_MODEL_UPDATEAUTOGROUPINGRULERESULT_H_

resourcemanager/include/alibabacloud/resourcemanager/model/UpdateRoleResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct Role
 				{
-					std::string updateDate;
 					long maxSessionDuration;
+					std::string updateDate;
 					std::string roleName;
 					std::string description;
 					std::string assumeRolePolicyDocument;

resourcemanager/src/ResourceManagerClient.cc

@@ -31,21 +31,21 @@ ResourceManagerClient::ResourceManagerClient(const Credentials &credentials, con
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager");
 }
 
 ResourceManagerClient::ResourceManagerClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager");
 }
 
 ResourceManagerClient::ResourceManagerClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "resourcemanager");
 }
 
 ResourceManagerClient::~ResourceManagerClient()
@@ -411,6 +411,42 @@ ResourceManagerClient::CheckAccountDeleteOutcomeCallable ResourceManagerClient::
 	return task->get_future();
 }
 
+ResourceManagerClient::CreateAutoGroupingRuleOutcome ResourceManagerClient::createAutoGroupingRule(const CreateAutoGroupingRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateAutoGroupingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateAutoGroupingRuleOutcome(CreateAutoGroupingRuleResult(outcome.result()));
+	else
+		return CreateAutoGroupingRuleOutcome(outcome.error());
+}
+
+void ResourceManagerClient::createAutoGroupingRuleAsync(const CreateAutoGroupingRuleRequest& request, const CreateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createAutoGroupingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::CreateAutoGroupingRuleOutcomeCallable ResourceManagerClient::createAutoGroupingRuleCallable(const CreateAutoGroupingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateAutoGroupingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->createAutoGroupingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::CreateCloudAccountOutcome ResourceManagerClient::createCloudAccount(const CreateCloudAccountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +843,42 @@ ResourceManagerClient::DeleteAccountOutcomeCallable ResourceManagerClient::delet
 	return task->get_future();
 }
 
+ResourceManagerClient::DeleteAutoGroupingRuleOutcome ResourceManagerClient::deleteAutoGroupingRule(const DeleteAutoGroupingRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteAutoGroupingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteAutoGroupingRuleOutcome(DeleteAutoGroupingRuleResult(outcome.result()));
+	else
+		return DeleteAutoGroupingRuleOutcome(outcome.error());
+}
+
+void ResourceManagerClient::deleteAutoGroupingRuleAsync(const DeleteAutoGroupingRuleRequest& request, const DeleteAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteAutoGroupingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::DeleteAutoGroupingRuleOutcomeCallable ResourceManagerClient::deleteAutoGroupingRuleCallable(const DeleteAutoGroupingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteAutoGroupingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteAutoGroupingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::DeleteControlPolicyOutcome ResourceManagerClient::deleteControlPolicy(const DeleteControlPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,6 +1275,78 @@ ResourceManagerClient::DetachPolicyOutcomeCallable ResourceManagerClient::detach
 	return task->get_future();
 }
 
+ResourceManagerClient::DisableAssociatedTransferOutcome ResourceManagerClient::disableAssociatedTransfer(const DisableAssociatedTransferRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableAssociatedTransferOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableAssociatedTransferOutcome(DisableAssociatedTransferResult(outcome.result()));
+	else
+		return DisableAssociatedTransferOutcome(outcome.error());
+}
+
+void ResourceManagerClient::disableAssociatedTransferAsync(const DisableAssociatedTransferRequest& request, const DisableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableAssociatedTransfer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::DisableAssociatedTransferOutcomeCallable ResourceManagerClient::disableAssociatedTransferCallable(const DisableAssociatedTransferRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableAssociatedTransferOutcome()>>(
+			[this, request]()
+			{
+			return this->disableAssociatedTransfer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceManagerClient::DisableAutoGroupingOutcome ResourceManagerClient::disableAutoGrouping(const DisableAutoGroupingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableAutoGroupingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableAutoGroupingOutcome(DisableAutoGroupingResult(outcome.result()));
+	else
+		return DisableAutoGroupingOutcome(outcome.error());
+}
+
+void ResourceManagerClient::disableAutoGroupingAsync(const DisableAutoGroupingRequest& request, const DisableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableAutoGrouping(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::DisableAutoGroupingOutcomeCallable ResourceManagerClient::disableAutoGroupingCallable(const DisableAutoGroupingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableAutoGroupingOutcome()>>(
+			[this, request]()
+			{
+			return this->disableAutoGrouping(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::DisableControlPolicyOutcome ResourceManagerClient::disableControlPolicy(const DisableControlPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1383,78 @@ ResourceManagerClient::DisableControlPolicyOutcomeCallable ResourceManagerClient
 	return task->get_future();
 }
 
+ResourceManagerClient::EnableAssociatedTransferOutcome ResourceManagerClient::enableAssociatedTransfer(const EnableAssociatedTransferRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableAssociatedTransferOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableAssociatedTransferOutcome(EnableAssociatedTransferResult(outcome.result()));
+	else
+		return EnableAssociatedTransferOutcome(outcome.error());
+}
+
+void ResourceManagerClient::enableAssociatedTransferAsync(const EnableAssociatedTransferRequest& request, const EnableAssociatedTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableAssociatedTransfer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::EnableAssociatedTransferOutcomeCallable ResourceManagerClient::enableAssociatedTransferCallable(const EnableAssociatedTransferRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableAssociatedTransferOutcome()>>(
+			[this, request]()
+			{
+			return this->enableAssociatedTransfer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceManagerClient::EnableAutoGroupingOutcome ResourceManagerClient::enableAutoGrouping(const EnableAutoGroupingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableAutoGroupingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableAutoGroupingOutcome(EnableAutoGroupingResult(outcome.result()));
+	else
+		return EnableAutoGroupingOutcome(outcome.error());
+}
+
+void ResourceManagerClient::enableAutoGroupingAsync(const EnableAutoGroupingRequest& request, const EnableAutoGroupingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableAutoGrouping(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::EnableAutoGroupingOutcomeCallable ResourceManagerClient::enableAutoGroupingCallable(const EnableAutoGroupingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableAutoGroupingOutcome()>>(
+			[this, request]()
+			{
+			return this->enableAutoGrouping(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::EnableControlPolicyOutcome ResourceManagerClient::enableControlPolicy(const EnableControlPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1635,78 @@ ResourceManagerClient::GetAccountDeletionStatusOutcomeCallable ResourceManagerCl
 	return task->get_future();
 }
 
+ResourceManagerClient::GetAutoGroupingRuleOutcome ResourceManagerClient::getAutoGroupingRule(const GetAutoGroupingRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAutoGroupingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAutoGroupingRuleOutcome(GetAutoGroupingRuleResult(outcome.result()));
+	else
+		return GetAutoGroupingRuleOutcome(outcome.error());
+}
+
+void ResourceManagerClient::getAutoGroupingRuleAsync(const GetAutoGroupingRuleRequest& request, const GetAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAutoGroupingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::GetAutoGroupingRuleOutcomeCallable ResourceManagerClient::getAutoGroupingRuleCallable(const GetAutoGroupingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAutoGroupingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->getAutoGroupingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceManagerClient::GetAutoGroupingStatusOutcome ResourceManagerClient::getAutoGroupingStatus(const GetAutoGroupingStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAutoGroupingStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAutoGroupingStatusOutcome(GetAutoGroupingStatusResult(outcome.result()));
+	else
+		return GetAutoGroupingStatusOutcome(outcome.error());
+}
+
+void ResourceManagerClient::getAutoGroupingStatusAsync(const GetAutoGroupingStatusRequest& request, const GetAutoGroupingStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAutoGroupingStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::GetAutoGroupingStatusOutcomeCallable ResourceManagerClient::getAutoGroupingStatusCallable(const GetAutoGroupingStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAutoGroupingStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getAutoGroupingStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::GetControlPolicyOutcome ResourceManagerClient::getControlPolicy(const GetControlPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1995,6 +2283,78 @@ ResourceManagerClient::ListAncestorsOutcomeCallable ResourceManagerClient::listA
 	return task->get_future();
 }
 
+ResourceManagerClient::ListAssociatedTransferSettingOutcome ResourceManagerClient::listAssociatedTransferSetting(const ListAssociatedTransferSettingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAssociatedTransferSettingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAssociatedTransferSettingOutcome(ListAssociatedTransferSettingResult(outcome.result()));
+	else
+		return ListAssociatedTransferSettingOutcome(outcome.error());
+}
+
+void ResourceManagerClient::listAssociatedTransferSettingAsync(const ListAssociatedTransferSettingRequest& request, const ListAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAssociatedTransferSetting(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::ListAssociatedTransferSettingOutcomeCallable ResourceManagerClient::listAssociatedTransferSettingCallable(const ListAssociatedTransferSettingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAssociatedTransferSettingOutcome()>>(
+			[this, request]()
+			{
+			return this->listAssociatedTransferSetting(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceManagerClient::ListAutoGroupingRulesOutcome ResourceManagerClient::listAutoGroupingRules(const ListAutoGroupingRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAutoGroupingRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAutoGroupingRulesOutcome(ListAutoGroupingRulesResult(outcome.result()));
+	else
+		return ListAutoGroupingRulesOutcome(outcome.error());
+}
+
+void ResourceManagerClient::listAutoGroupingRulesAsync(const ListAutoGroupingRulesRequest& request, const ListAutoGroupingRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAutoGroupingRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::ListAutoGroupingRulesOutcomeCallable ResourceManagerClient::listAutoGroupingRulesCallable(const ListAutoGroupingRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAutoGroupingRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listAutoGroupingRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::ListControlPoliciesOutcome ResourceManagerClient::listControlPolicies(const ListControlPoliciesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3183,6 +3543,114 @@ ResourceManagerClient::UpdateAccountOutcomeCallable ResourceManagerClient::updat
 	return task->get_future();
 }
 
+ResourceManagerClient::UpdateAssociatedTransferSettingOutcome ResourceManagerClient::updateAssociatedTransferSetting(const UpdateAssociatedTransferSettingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAssociatedTransferSettingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAssociatedTransferSettingOutcome(UpdateAssociatedTransferSettingResult(outcome.result()));
+	else
+		return UpdateAssociatedTransferSettingOutcome(outcome.error());
+}
+
+void ResourceManagerClient::updateAssociatedTransferSettingAsync(const UpdateAssociatedTransferSettingRequest& request, const UpdateAssociatedTransferSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAssociatedTransferSetting(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::UpdateAssociatedTransferSettingOutcomeCallable ResourceManagerClient::updateAssociatedTransferSettingCallable(const UpdateAssociatedTransferSettingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAssociatedTransferSettingOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAssociatedTransferSetting(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceManagerClient::UpdateAutoGroupingConfigOutcome ResourceManagerClient::updateAutoGroupingConfig(const UpdateAutoGroupingConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAutoGroupingConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAutoGroupingConfigOutcome(UpdateAutoGroupingConfigResult(outcome.result()));
+	else
+		return UpdateAutoGroupingConfigOutcome(outcome.error());
+}
+
+void ResourceManagerClient::updateAutoGroupingConfigAsync(const UpdateAutoGroupingConfigRequest& request, const UpdateAutoGroupingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAutoGroupingConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::UpdateAutoGroupingConfigOutcomeCallable ResourceManagerClient::updateAutoGroupingConfigCallable(const UpdateAutoGroupingConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAutoGroupingConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAutoGroupingConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceManagerClient::UpdateAutoGroupingRuleOutcome ResourceManagerClient::updateAutoGroupingRule(const UpdateAutoGroupingRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAutoGroupingRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAutoGroupingRuleOutcome(UpdateAutoGroupingRuleResult(outcome.result()));
+	else
+		return UpdateAutoGroupingRuleOutcome(outcome.error());
+}
+
+void ResourceManagerClient::updateAutoGroupingRuleAsync(const UpdateAutoGroupingRuleRequest& request, const UpdateAutoGroupingRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAutoGroupingRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceManagerClient::UpdateAutoGroupingRuleOutcomeCallable ResourceManagerClient::updateAutoGroupingRuleCallable(const UpdateAutoGroupingRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAutoGroupingRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAutoGroupingRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ResourceManagerClient::UpdateControlPolicyOutcome ResourceManagerClient::updateControlPolicy(const UpdateControlPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

resourcemanager/src/model/AttachPolicyRequest.cc

@@ -25,6 +25,15 @@ AttachPolicyRequest::AttachPolicyRequest()
 
 AttachPolicyRequest::~AttachPolicyRequest() {}
 
+std::string AttachPolicyRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void AttachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string AttachPolicyRequest::getPolicyType() const {
   return policyType_;
 }
@@ -43,15 +52,6 @@ void AttachPolicyRequest::setPrincipalType(const std::string &principalType) {
   setParameter(std::string("PrincipalType"), principalType);
 }
 
-std::string AttachPolicyRequest::getResourceGroupId() const {
-  return resourceGroupId_;
-}
-
-void AttachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
-  resourceGroupId_ = resourceGroupId;
-  setParameter(std::string("ResourceGroupId"), resourceGroupId);
-}
-
 std::string AttachPolicyRequest::getPolicyName() const {
   return policyName_;
 }

resourcemanager/src/model/CreateAutoGroupingRuleRequest.cc

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/CreateAutoGroupingRuleRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::CreateAutoGroupingRuleRequest;
+
+CreateAutoGroupingRuleRequest::CreateAutoGroupingRuleRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "CreateAutoGroupingRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateAutoGroupingRuleRequest::~CreateAutoGroupingRuleRequest() {}
+
+std::string CreateAutoGroupingRuleRequest::getRuleDesc() const {
+  return ruleDesc_;
+}
+
+void CreateAutoGroupingRuleRequest::setRuleDesc(const std::string &ruleDesc) {
+  ruleDesc_ = ruleDesc;
+  setParameter(std::string("RuleDesc"), ruleDesc);
+}
+
+std::string CreateAutoGroupingRuleRequest::getResourceTypesScope() const {
+  return resourceTypesScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setResourceTypesScope(const std::string &resourceTypesScope) {
+  resourceTypesScope_ = resourceTypesScope;
+  setParameter(std::string("ResourceTypesScope"), resourceTypesScope);
+}
+
+std::string CreateAutoGroupingRuleRequest::getRuleName() const {
+  return ruleName_;
+}
+
+void CreateAutoGroupingRuleRequest::setRuleName(const std::string &ruleName) {
+  ruleName_ = ruleName;
+  setParameter(std::string("RuleName"), ruleName);
+}
+
+std::string CreateAutoGroupingRuleRequest::getExcludeResourceGroupIdsScope() const {
+  return excludeResourceGroupIdsScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope) {
+  excludeResourceGroupIdsScope_ = excludeResourceGroupIdsScope;
+  setParameter(std::string("ExcludeResourceGroupIdsScope"), excludeResourceGroupIdsScope);
+}
+
+std::string CreateAutoGroupingRuleRequest::getRegionIdsScope() const {
+  return regionIdsScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setRegionIdsScope(const std::string &regionIdsScope) {
+  regionIdsScope_ = regionIdsScope;
+  setParameter(std::string("RegionIdsScope"), regionIdsScope);
+}
+
+std::string CreateAutoGroupingRuleRequest::getResourceIdsScope() const {
+  return resourceIdsScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setResourceIdsScope(const std::string &resourceIdsScope) {
+  resourceIdsScope_ = resourceIdsScope;
+  setParameter(std::string("ResourceIdsScope"), resourceIdsScope);
+}
+
+std::vector<CreateAutoGroupingRuleRequest::RuleContents> CreateAutoGroupingRuleRequest::getRuleContents() const {
+  return ruleContents_;
+}
+
+void CreateAutoGroupingRuleRequest::setRuleContents(const std::vector<CreateAutoGroupingRuleRequest::RuleContents> &ruleContents) {
+  ruleContents_ = ruleContents;
+  for(int dep1 = 0; dep1 != ruleContents.size(); dep1++) {
+  auto ruleContentsObj = ruleContents.at(dep1);
+  std::string ruleContentsObjStr = std::string("RuleContents") + "." + std::to_string(dep1 + 1);
+    setParameter(ruleContentsObjStr + ".TargetResourceGroupCondition", ruleContentsObj.targetResourceGroupCondition);
+    setParameter(ruleContentsObjStr + ".AutoGroupingScopeCondition", ruleContentsObj.autoGroupingScopeCondition);
+  }
+}
+
+std::string CreateAutoGroupingRuleRequest::getExcludeResourceTypesScope() const {
+  return excludeResourceTypesScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope) {
+  excludeResourceTypesScope_ = excludeResourceTypesScope;
+  setParameter(std::string("ExcludeResourceTypesScope"), excludeResourceTypesScope);
+}
+
+std::string CreateAutoGroupingRuleRequest::getRuleType() const {
+  return ruleType_;
+}
+
+void CreateAutoGroupingRuleRequest::setRuleType(const std::string &ruleType) {
+  ruleType_ = ruleType;
+  setParameter(std::string("RuleType"), ruleType);
+}
+
+std::string CreateAutoGroupingRuleRequest::getResourceGroupIdsScope() const {
+  return resourceGroupIdsScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setResourceGroupIdsScope(const std::string &resourceGroupIdsScope) {
+  resourceGroupIdsScope_ = resourceGroupIdsScope;
+  setParameter(std::string("ResourceGroupIdsScope"), resourceGroupIdsScope);
+}
+
+std::string CreateAutoGroupingRuleRequest::getExcludeRegionIdsScope() const {
+  return excludeRegionIdsScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope) {
+  excludeRegionIdsScope_ = excludeRegionIdsScope;
+  setParameter(std::string("ExcludeRegionIdsScope"), excludeRegionIdsScope);
+}
+
+std::string CreateAutoGroupingRuleRequest::getExcludeResourceIdsScope() const {
+  return excludeResourceIdsScope_;
+}
+
+void CreateAutoGroupingRuleRequest::setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope) {
+  excludeResourceIdsScope_ = excludeResourceIdsScope;
+  setParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
+}
+

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

resourcemanager/src/model/CreateCloudAccountResult.cc

@@ -40,26 +40,26 @@ void CreateCloudAccountResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto accountNode = value["Account"];
-	if(!accountNode["Status"].isNull())
-		account_.status = accountNode["Status"].asString();
-	if(!accountNode["Type"].isNull())
-		account_.type = accountNode["Type"].asString();
+	if(!accountNode["AccountId"].isNull())
+		account_.accountId = accountNode["AccountId"].asString();
+	if(!accountNode["AccountName"].isNull())
+		account_.accountName = accountNode["AccountName"].asString();
 	if(!accountNode["DisplayName"].isNull())
 		account_.displayName = accountNode["DisplayName"].asString();
 	if(!accountNode["FolderId"].isNull())
 		account_.folderId = accountNode["FolderId"].asString();
-	if(!accountNode["ResourceDirectoryId"].isNull())
-		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
-	if(!accountNode["RecordId"].isNull())
-		account_.recordId = accountNode["RecordId"].asString();
-	if(!accountNode["AccountId"].isNull())
-		account_.accountId = accountNode["AccountId"].asString();
 	if(!accountNode["JoinMethod"].isNull())
 		account_.joinMethod = accountNode["JoinMethod"].asString();
 	if(!accountNode["ModifyTime"].isNull())
 		account_.modifyTime = accountNode["ModifyTime"].asString();
-	if(!accountNode["AccountName"].isNull())
-		account_.accountName = accountNode["AccountName"].asString();
+	if(!accountNode["RecordId"].isNull())
+		account_.recordId = accountNode["RecordId"].asString();
+	if(!accountNode["ResourceDirectoryId"].isNull())
+		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
+	if(!accountNode["Status"].isNull())
+		account_.status = accountNode["Status"].asString();
+	if(!accountNode["Type"].isNull())
+		account_.type = accountNode["Type"].asString();
 
 }
 

resourcemanager/src/model/CreatePolicyResult.cc

@@ -40,14 +40,14 @@ void CreatePolicyResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto policyNode = value["Policy"];
+	if(!policyNode["CreateDate"].isNull())
+		policy_.createDate = policyNode["CreateDate"].asString();
 	if(!policyNode["DefaultVersion"].isNull())
 		policy_.defaultVersion = policyNode["DefaultVersion"].asString();
 	if(!policyNode["Description"].isNull())
 		policy_.description = policyNode["Description"].asString();
 	if(!policyNode["PolicyName"].isNull())
 		policy_.policyName = policyNode["PolicyName"].asString();
-	if(!policyNode["CreateDate"].isNull())
-		policy_.createDate = policyNode["CreateDate"].asString();
 	if(!policyNode["PolicyType"].isNull())
 		policy_.policyType = policyNode["PolicyType"].asString();
 

resourcemanager/src/model/CreatePolicyVersionResult.cc

@@ -40,12 +40,12 @@ void CreatePolicyVersionResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto policyVersionNode = value["PolicyVersion"];
+	if(!policyVersionNode["CreateDate"].isNull())
+		policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
 	if(!policyVersionNode["IsDefaultVersion"].isNull())
 		policyVersion_.isDefaultVersion = policyVersionNode["IsDefaultVersion"].asString() == "true";
 	if(!policyVersionNode["VersionId"].isNull())
 		policyVersion_.versionId = policyVersionNode["VersionId"].asString();
-	if(!policyVersionNode["CreateDate"].isNull())
-		policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
 
 }
 

resourcemanager/src/model/CreateResourceGroupRequest.cc

@@ -43,3 +43,15 @@ void CreateResourceGroupRequest::setName(const std::string &name) {
   setParameter(std::string("Name"), name);
 }
 
+std::vector<CreateResourceGroupRequest::Tag> CreateResourceGroupRequest::getTag() const {
+  return tag_;
+}
+
+void CreateResourceGroupRequest::setTag(const std::vector<CreateResourceGroupRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
+    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
+  }
+}
+

resourcemanager/src/model/CreateResourceGroupResult.cc

@@ -40,26 +40,26 @@ void CreateResourceGroupResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resourceGroupNode = value["ResourceGroup"];
-	if(!resourceGroupNode["DisplayName"].isNull())
-		resourceGroup_.displayName = resourceGroupNode["DisplayName"].asString();
-	if(!resourceGroupNode["Status"].isNull())
-		resourceGroup_.status = resourceGroupNode["Status"].asString();
 	if(!resourceGroupNode["AccountId"].isNull())
 		resourceGroup_.accountId = resourceGroupNode["AccountId"].asString();
-	if(!resourceGroupNode["Name"].isNull())
-		resourceGroup_.name = resourceGroupNode["Name"].asString();
 	if(!resourceGroupNode["CreateDate"].isNull())
 		resourceGroup_.createDate = resourceGroupNode["CreateDate"].asString();
+	if(!resourceGroupNode["DisplayName"].isNull())
+		resourceGroup_.displayName = resourceGroupNode["DisplayName"].asString();
 	if(!resourceGroupNode["Id"].isNull())
 		resourceGroup_.id = resourceGroupNode["Id"].asString();
+	if(!resourceGroupNode["Name"].isNull())
+		resourceGroup_.name = resourceGroupNode["Name"].asString();
+	if(!resourceGroupNode["Status"].isNull())
+		resourceGroup_.status = resourceGroupNode["Status"].asString();
 	auto allRegionStatusesNode = resourceGroupNode["RegionStatuses"]["RegionStatus"];
 	for (auto resourceGroupNodeRegionStatusesRegionStatus : allRegionStatusesNode)
 	{
 		ResourceGroup::RegionStatus regionStatusObject;
-		if(!resourceGroupNodeRegionStatusesRegionStatus["Status"].isNull())
-			regionStatusObject.status = resourceGroupNodeRegionStatusesRegionStatus["Status"].asString();
 		if(!resourceGroupNodeRegionStatusesRegionStatus["RegionId"].isNull())
 			regionStatusObject.regionId = resourceGroupNodeRegionStatusesRegionStatus["RegionId"].asString();
+		if(!resourceGroupNodeRegionStatusesRegionStatus["Status"].isNull())
+			regionStatusObject.status = resourceGroupNodeRegionStatusesRegionStatus["Status"].asString();
 		resourceGroup_.regionStatuses.push_back(regionStatusObject);
 	}
 

resourcemanager/src/model/CreateRoleResult.cc

@@ -40,22 +40,22 @@ void CreateRoleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto roleNode = value["Role"];
+	if(!roleNode["Arn"].isNull())
+		role_.arn = roleNode["Arn"].asString();
 	if(!roleNode["AssumeRolePolicyDocument"].isNull())
 		role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
-	if(!roleNode["RolePrincipalName"].isNull())
-		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
+	if(!roleNode["CreateDate"].isNull())
+		role_.createDate = roleNode["CreateDate"].asString();
 	if(!roleNode["Description"].isNull())
 		role_.description = roleNode["Description"].asString();
 	if(!roleNode["MaxSessionDuration"].isNull())
 		role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
-	if(!roleNode["RoleName"].isNull())
-		role_.roleName = roleNode["RoleName"].asString();
-	if(!roleNode["CreateDate"].isNull())
-		role_.createDate = roleNode["CreateDate"].asString();
-	if(!roleNode["Arn"].isNull())
-		role_.arn = roleNode["Arn"].asString();
 	if(!roleNode["RoleId"].isNull())
 		role_.roleId = roleNode["RoleId"].asString();
+	if(!roleNode["RoleName"].isNull())
+		role_.roleName = roleNode["RoleName"].asString();
+	if(!roleNode["RolePrincipalName"].isNull())
+		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
 
 }
 

resourcemanager/src/model/CreateServiceLinkedRoleResult.cc

@@ -40,22 +40,22 @@ void CreateServiceLinkedRoleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto roleNode = value["Role"];
+	if(!roleNode["Arn"].isNull())
+		role_.arn = roleNode["Arn"].asString();
 	if(!roleNode["AssumeRolePolicyDocument"].isNull())
 		role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
-	if(!roleNode["RolePrincipalName"].isNull())
-		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
-	if(!roleNode["Description"].isNull())
-		role_.description = roleNode["Description"].asString();
-	if(!roleNode["RoleName"].isNull())
-		role_.roleName = roleNode["RoleName"].asString();
 	if(!roleNode["CreateDate"].isNull())
 		role_.createDate = roleNode["CreateDate"].asString();
-	if(!roleNode["Arn"].isNull())
-		role_.arn = roleNode["Arn"].asString();
-	if(!roleNode["RoleId"].isNull())
-		role_.roleId = roleNode["RoleId"].asString();
+	if(!roleNode["Description"].isNull())
+		role_.description = roleNode["Description"].asString();
 	if(!roleNode["IsServiceLinkedRole"].isNull())
 		role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true";
+	if(!roleNode["RoleId"].isNull())
+		role_.roleId = roleNode["RoleId"].asString();
+	if(!roleNode["RoleName"].isNull())
+		role_.roleName = roleNode["RoleName"].asString();
+	if(!roleNode["RolePrincipalName"].isNull())
+		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
 
 }
 

resourcemanager/src/model/DeleteAutoGroupingRuleRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/DeleteAutoGroupingRuleRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::DeleteAutoGroupingRuleRequest;
+
+DeleteAutoGroupingRuleRequest::DeleteAutoGroupingRuleRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "DeleteAutoGroupingRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteAutoGroupingRuleRequest::~DeleteAutoGroupingRuleRequest() {}
+
+std::string DeleteAutoGroupingRuleRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void DeleteAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), ruleId);
+}
+

resourcemanager/src/model/DeleteAutoGroupingRuleResult.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/resourcemanager/model/DeleteAutoGroupingRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+DeleteAutoGroupingRuleResult::DeleteAutoGroupingRuleResult() :
+	ServiceResult()
+{}
+
+DeleteAutoGroupingRuleResult::DeleteAutoGroupingRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteAutoGroupingRuleResult::~DeleteAutoGroupingRuleResult()
+{}
+
+void DeleteAutoGroupingRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/DetachPolicyRequest.cc

@@ -25,6 +25,15 @@ DetachPolicyRequest::DetachPolicyRequest()
 
 DetachPolicyRequest::~DetachPolicyRequest() {}
 
+std::string DetachPolicyRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DetachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string DetachPolicyRequest::getPolicyType() const {
   return policyType_;
 }
@@ -43,15 +52,6 @@ void DetachPolicyRequest::setPrincipalType(const std::string &principalType) {
   setParameter(std::string("PrincipalType"), principalType);
 }
 
-std::string DetachPolicyRequest::getResourceGroupId() const {
-  return resourceGroupId_;
-}
-
-void DetachPolicyRequest::setResourceGroupId(const std::string &resourceGroupId) {
-  resourceGroupId_ = resourceGroupId;
-  setParameter(std::string("ResourceGroupId"), resourceGroupId);
-}
-
 std::string DetachPolicyRequest::getPolicyName() const {
   return policyName_;
 }

resourcemanager/src/model/DisableAssociatedTransferRequest.cc

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

resourcemanager/src/model/DisableAssociatedTransferResult.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/resourcemanager/model/DisableAssociatedTransferResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+DisableAssociatedTransferResult::DisableAssociatedTransferResult() :
+	ServiceResult()
+{}
+
+DisableAssociatedTransferResult::DisableAssociatedTransferResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DisableAssociatedTransferResult::~DisableAssociatedTransferResult()
+{}
+
+void DisableAssociatedTransferResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/DisableAutoGroupingRequest.cc

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

resourcemanager/src/model/DisableAutoGroupingResult.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/resourcemanager/model/DisableAutoGroupingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+DisableAutoGroupingResult::DisableAutoGroupingResult() :
+	ServiceResult()
+{}
+
+DisableAutoGroupingResult::DisableAutoGroupingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DisableAutoGroupingResult::~DisableAutoGroupingResult()
+{}
+
+void DisableAutoGroupingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/EnableAssociatedTransferRequest.cc

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

resourcemanager/src/model/EnableAssociatedTransferResult.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/resourcemanager/model/EnableAssociatedTransferResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+EnableAssociatedTransferResult::EnableAssociatedTransferResult() :
+	ServiceResult()
+{}
+
+EnableAssociatedTransferResult::EnableAssociatedTransferResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnableAssociatedTransferResult::~EnableAssociatedTransferResult()
+{}
+
+void EnableAssociatedTransferResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/EnableAutoGroupingRequest.cc

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

resourcemanager/src/model/EnableAutoGroupingResult.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/resourcemanager/model/EnableAutoGroupingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+EnableAutoGroupingResult::EnableAutoGroupingResult() :
+	ServiceResult()
+{}
+
+EnableAutoGroupingResult::EnableAutoGroupingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnableAutoGroupingResult::~EnableAutoGroupingResult()
+{}
+
+void EnableAutoGroupingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/GetAutoGroupingRuleRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/GetAutoGroupingRuleRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::GetAutoGroupingRuleRequest;
+
+GetAutoGroupingRuleRequest::GetAutoGroupingRuleRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "GetAutoGroupingRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAutoGroupingRuleRequest::~GetAutoGroupingRuleRequest() {}
+
+std::string GetAutoGroupingRuleRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void GetAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), ruleId);
+}
+

resourcemanager/src/model/GetAutoGroupingRuleResult.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/resourcemanager/model/GetAutoGroupingRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+GetAutoGroupingRuleResult::GetAutoGroupingRuleResult() :
+	ServiceResult()
+{}
+
+GetAutoGroupingRuleResult::GetAutoGroupingRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAutoGroupingRuleResult::~GetAutoGroupingRuleResult()
+{}
+
+void GetAutoGroupingRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto ruleNode = value["Rule"];
+	if(!ruleNode["CreateTime"].isNull())
+		rule_.createTime = ruleNode["CreateTime"].asString();
+	if(!ruleNode["ExcludeRegionIdsScope"].isNull())
+		rule_.excludeRegionIdsScope = ruleNode["ExcludeRegionIdsScope"].asString();
+	if(!ruleNode["ExcludeResourceGroupIdsScope"].isNull())
+		rule_.excludeResourceGroupIdsScope = ruleNode["ExcludeResourceGroupIdsScope"].asString();
+	if(!ruleNode["ExcludeResourceIdsScope"].isNull())
+		rule_.excludeResourceIdsScope = ruleNode["ExcludeResourceIdsScope"].asString();
+	if(!ruleNode["ExcludeResourceTypesScope"].isNull())
+		rule_.excludeResourceTypesScope = ruleNode["ExcludeResourceTypesScope"].asString();
+	if(!ruleNode["ModifyTime"].isNull())
+		rule_.modifyTime = ruleNode["ModifyTime"].asString();
+	if(!ruleNode["RegionIdsScope"].isNull())
+		rule_.regionIdsScope = ruleNode["RegionIdsScope"].asString();
+	if(!ruleNode["ResourceGroupIdsScope"].isNull())
+		rule_.resourceGroupIdsScope = ruleNode["ResourceGroupIdsScope"].asString();
+	if(!ruleNode["ResourceIdsScope"].isNull())
+		rule_.resourceIdsScope = ruleNode["ResourceIdsScope"].asString();
+	if(!ruleNode["ResourceTypesScope"].isNull())
+		rule_.resourceTypesScope = ruleNode["ResourceTypesScope"].asString();
+	if(!ruleNode["RuleDesc"].isNull())
+		rule_.ruleDesc = ruleNode["RuleDesc"].asString();
+	if(!ruleNode["RuleId"].isNull())
+		rule_.ruleId = ruleNode["RuleId"].asString();
+	if(!ruleNode["RuleName"].isNull())
+		rule_.ruleName = ruleNode["RuleName"].asString();
+	if(!ruleNode["RuleType"].isNull())
+		rule_.ruleType = ruleNode["RuleType"].asString();
+	auto allRuleContentsNode = ruleNode["RuleContents"]["RuleContent"];
+	for (auto ruleNodeRuleContentsRuleContent : allRuleContentsNode)
+	{
+		Rule::RuleContent ruleContentObject;
+		if(!ruleNodeRuleContentsRuleContent["AutoGroupingScopeCondition"].isNull())
+			ruleContentObject.autoGroupingScopeCondition = ruleNodeRuleContentsRuleContent["AutoGroupingScopeCondition"].asString();
+		if(!ruleNodeRuleContentsRuleContent["RuleContentId"].isNull())
+			ruleContentObject.ruleContentId = ruleNodeRuleContentsRuleContent["RuleContentId"].asString();
+		if(!ruleNodeRuleContentsRuleContent["TargetResourceGroupCondition"].isNull())
+			ruleContentObject.targetResourceGroupCondition = ruleNodeRuleContentsRuleContent["TargetResourceGroupCondition"].asString();
+		rule_.ruleContents.push_back(ruleContentObject);
+	}
+
+}
+
+GetAutoGroupingRuleResult::Rule GetAutoGroupingRuleResult::getRule()const
+{
+	return rule_;
+}
+

resourcemanager/src/model/GetAutoGroupingStatusRequest.cc

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

resourcemanager/src/model/GetAutoGroupingStatusResult.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/resourcemanager/model/GetAutoGroupingStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+GetAutoGroupingStatusResult::GetAutoGroupingStatusResult() :
+	ServiceResult()
+{}
+
+GetAutoGroupingStatusResult::GetAutoGroupingStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAutoGroupingStatusResult::~GetAutoGroupingStatusResult()
+{}
+
+void GetAutoGroupingStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EnableExistedResourcesTransfer"].isNull())
+		enableExistedResourcesTransfer_ = value["EnableExistedResourcesTransfer"].asString() == "true";
+	if(!value["EnableStatus"].isNull())
+		enableStatus_ = value["EnableStatus"].asString();
+
+}
+
+std::string GetAutoGroupingStatusResult::getEnableStatus()const
+{
+	return enableStatus_;
+}
+
+bool GetAutoGroupingStatusResult::getEnableExistedResourcesTransfer()const
+{
+	return enableExistedResourcesTransfer_;
+}
+

resourcemanager/src/model/GetPolicyResult.cc

@@ -40,22 +40,22 @@ void GetPolicyResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto policyNode = value["Policy"];
+	if(!policyNode["AttachmentCount"].isNull())
+		policy_.attachmentCount = std::stoi(policyNode["AttachmentCount"].asString());
+	if(!policyNode["CreateDate"].isNull())
+		policy_.createDate = policyNode["CreateDate"].asString();
 	if(!policyNode["DefaultVersion"].isNull())
 		policy_.defaultVersion = policyNode["DefaultVersion"].asString();
-	if(!policyNode["UpdateDate"].isNull())
-		policy_.updateDate = policyNode["UpdateDate"].asString();
 	if(!policyNode["Description"].isNull())
 		policy_.description = policyNode["Description"].asString();
 	if(!policyNode["PolicyDocument"].isNull())
 		policy_.policyDocument = policyNode["PolicyDocument"].asString();
-	if(!policyNode["AttachmentCount"].isNull())
-		policy_.attachmentCount = std::stoi(policyNode["AttachmentCount"].asString());
 	if(!policyNode["PolicyName"].isNull())
 		policy_.policyName = policyNode["PolicyName"].asString();
-	if(!policyNode["CreateDate"].isNull())
-		policy_.createDate = policyNode["CreateDate"].asString();
 	if(!policyNode["PolicyType"].isNull())
 		policy_.policyType = policyNode["PolicyType"].asString();
+	if(!policyNode["UpdateDate"].isNull())
+		policy_.updateDate = policyNode["UpdateDate"].asString();
 
 }
 

resourcemanager/src/model/GetPolicyVersionResult.cc

@@ -40,14 +40,14 @@ void GetPolicyVersionResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto policyVersionNode = value["PolicyVersion"];
+	if(!policyVersionNode["CreateDate"].isNull())
+		policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
 	if(!policyVersionNode["IsDefaultVersion"].isNull())
 		policyVersion_.isDefaultVersion = policyVersionNode["IsDefaultVersion"].asString() == "true";
 	if(!policyVersionNode["PolicyDocument"].isNull())
 		policyVersion_.policyDocument = policyVersionNode["PolicyDocument"].asString();
 	if(!policyVersionNode["VersionId"].isNull())
 		policyVersion_.versionId = policyVersionNode["VersionId"].asString();
-	if(!policyVersionNode["CreateDate"].isNull())
-		policyVersion_.createDate = policyVersionNode["CreateDate"].asString();
 
 }
 

resourcemanager/src/model/GetResourceDirectoryResult.cc

@@ -40,24 +40,24 @@ void GetResourceDirectoryResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resourceDirectoryNode = value["ResourceDirectory"];
-	if(!resourceDirectoryNode["RootFolderId"].isNull())
-		resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
-	if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
-		resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
+	if(!resourceDirectoryNode["ControlPolicyStatus"].isNull())
+		resourceDirectory_.controlPolicyStatus = resourceDirectoryNode["ControlPolicyStatus"].asString();
 	if(!resourceDirectoryNode["CreateTime"].isNull())
 		resourceDirectory_.createTime = resourceDirectoryNode["CreateTime"].asString();
+	if(!resourceDirectoryNode["IdentityInformation"].isNull())
+		resourceDirectory_.identityInformation = resourceDirectoryNode["IdentityInformation"].asString();
 	if(!resourceDirectoryNode["MasterAccountId"].isNull())
 		resourceDirectory_.masterAccountId = resourceDirectoryNode["MasterAccountId"].asString();
 	if(!resourceDirectoryNode["MasterAccountName"].isNull())
 		resourceDirectory_.masterAccountName = resourceDirectoryNode["MasterAccountName"].asString();
-	if(!resourceDirectoryNode["ScpStatus"].isNull())
-		resourceDirectory_.scpStatus = resourceDirectoryNode["ScpStatus"].asString();
-	if(!resourceDirectoryNode["ControlPolicyStatus"].isNull())
-		resourceDirectory_.controlPolicyStatus = resourceDirectoryNode["ControlPolicyStatus"].asString();
 	if(!resourceDirectoryNode["MemberDeletionStatus"].isNull())
 		resourceDirectory_.memberDeletionStatus = resourceDirectoryNode["MemberDeletionStatus"].asString();
-	if(!resourceDirectoryNode["IdentityInformation"].isNull())
-		resourceDirectory_.identityInformation = resourceDirectoryNode["IdentityInformation"].asString();
+	if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
+		resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
+	if(!resourceDirectoryNode["RootFolderId"].isNull())
+		resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
+	if(!resourceDirectoryNode["ScpStatus"].isNull())
+		resourceDirectory_.scpStatus = resourceDirectoryNode["ScpStatus"].asString();
 
 }
 

resourcemanager/src/model/GetRoleResult.cc

@@ -40,31 +40,31 @@ void GetRoleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto roleNode = value["Role"];
+	if(!roleNode["Arn"].isNull())
+		role_.arn = roleNode["Arn"].asString();
 	if(!roleNode["AssumeRolePolicyDocument"].isNull())
 		role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
-	if(!roleNode["RolePrincipalName"].isNull())
-		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
-	if(!roleNode["UpdateDate"].isNull())
-		role_.updateDate = roleNode["UpdateDate"].asString();
+	if(!roleNode["CreateDate"].isNull())
+		role_.createDate = roleNode["CreateDate"].asString();
 	if(!roleNode["Description"].isNull())
 		role_.description = roleNode["Description"].asString();
+	if(!roleNode["IsServiceLinkedRole"].isNull())
+		role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true";
 	if(!roleNode["MaxSessionDuration"].isNull())
 		role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
-	if(!roleNode["RoleName"].isNull())
-		role_.roleName = roleNode["RoleName"].asString();
-	if(!roleNode["CreateDate"].isNull())
-		role_.createDate = roleNode["CreateDate"].asString();
 	if(!roleNode["RoleId"].isNull())
 		role_.roleId = roleNode["RoleId"].asString();
-	if(!roleNode["Arn"].isNull())
-		role_.arn = roleNode["Arn"].asString();
-	if(!roleNode["IsServiceLinkedRole"].isNull())
-		role_.isServiceLinkedRole = roleNode["IsServiceLinkedRole"].asString() == "true";
+	if(!roleNode["RoleName"].isNull())
+		role_.roleName = roleNode["RoleName"].asString();
+	if(!roleNode["RolePrincipalName"].isNull())
+		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
+	if(!roleNode["UpdateDate"].isNull())
+		role_.updateDate = roleNode["UpdateDate"].asString();
 	auto latestDeletionTaskNode = roleNode["LatestDeletionTask"];
-	if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
-		role_.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
 	if(!latestDeletionTaskNode["CreateDate"].isNull())
 		role_.latestDeletionTask.createDate = latestDeletionTaskNode["CreateDate"].asString();
+	if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
+		role_.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
 
 }
 

resourcemanager/src/model/InitResourceDirectoryResult.cc

@@ -40,16 +40,16 @@ void InitResourceDirectoryResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto resourceDirectoryNode = value["ResourceDirectory"];
-	if(!resourceDirectoryNode["RootFolderId"].isNull())
-		resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
-	if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
-		resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
 	if(!resourceDirectoryNode["CreateTime"].isNull())
 		resourceDirectory_.createTime = resourceDirectoryNode["CreateTime"].asString();
 	if(!resourceDirectoryNode["MasterAccountId"].isNull())
 		resourceDirectory_.masterAccountId = resourceDirectoryNode["MasterAccountId"].asString();
 	if(!resourceDirectoryNode["MasterAccountName"].isNull())
 		resourceDirectory_.masterAccountName = resourceDirectoryNode["MasterAccountName"].asString();
+	if(!resourceDirectoryNode["ResourceDirectoryId"].isNull())
+		resourceDirectory_.resourceDirectoryId = resourceDirectoryNode["ResourceDirectoryId"].asString();
+	if(!resourceDirectoryNode["RootFolderId"].isNull())
+		resourceDirectory_.rootFolderId = resourceDirectoryNode["RootFolderId"].asString();
 
 }
 

resourcemanager/src/model/ListAccountsForParentRequest.cc

@@ -25,15 +25,6 @@ ListAccountsForParentRequest::ListAccountsForParentRequest()
 
 ListAccountsForParentRequest::~ListAccountsForParentRequest() {}
 
-std::string ListAccountsForParentRequest::getQueryKeyword() const {
-  return queryKeyword_;
-}
-
-void ListAccountsForParentRequest::setQueryKeyword(const std::string &queryKeyword) {
-  queryKeyword_ = queryKeyword;
-  setParameter(std::string("QueryKeyword"), queryKeyword);
-}
-
 int ListAccountsForParentRequest::getPageNumber() const {
   return pageNumber_;
 }
@@ -43,24 +34,6 @@ void ListAccountsForParentRequest::setPageNumber(int pageNumber) {
   setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-std::string ListAccountsForParentRequest::getParentFolderId() const {
-  return parentFolderId_;
-}
-
-void ListAccountsForParentRequest::setParentFolderId(const std::string &parentFolderId) {
-  parentFolderId_ = parentFolderId;
-  setParameter(std::string("ParentFolderId"), parentFolderId);
-}
-
-bool ListAccountsForParentRequest::getIncludeTags() const {
-  return includeTags_;
-}
-
-void ListAccountsForParentRequest::setIncludeTags(bool includeTags) {
-  includeTags_ = includeTags;
-  setParameter(std::string("IncludeTags"), includeTags ? "true" : "false");
-}
-
 int ListAccountsForParentRequest::getPageSize() const {
   return pageSize_;
 }
@@ -82,3 +55,30 @@ void ListAccountsForParentRequest::setTag(const std::vector<ListAccountsForParen
   }
 }
 
+std::string ListAccountsForParentRequest::getQueryKeyword() const {
+  return queryKeyword_;
+}
+
+void ListAccountsForParentRequest::setQueryKeyword(const std::string &queryKeyword) {
+  queryKeyword_ = queryKeyword;
+  setParameter(std::string("QueryKeyword"), queryKeyword);
+}
+
+std::string ListAccountsForParentRequest::getParentFolderId() const {
+  return parentFolderId_;
+}
+
+void ListAccountsForParentRequest::setParentFolderId(const std::string &parentFolderId) {
+  parentFolderId_ = parentFolderId;
+  setParameter(std::string("ParentFolderId"), parentFolderId);
+}
+
+bool ListAccountsForParentRequest::getIncludeTags() const {
+  return includeTags_;
+}
+
+void ListAccountsForParentRequest::setIncludeTags(bool includeTags) {
+  includeTags_ = includeTags;
+  setParameter(std::string("IncludeTags"), includeTags ? "true" : "false");
+}
+

resourcemanager/src/model/ListAssociatedTransferSettingRequest.cc

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

resourcemanager/src/model/ListAssociatedTransferSettingResult.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/resourcemanager/model/ListAssociatedTransferSettingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+ListAssociatedTransferSettingResult::ListAssociatedTransferSettingResult() :
+	ServiceResult()
+{}
+
+ListAssociatedTransferSettingResult::ListAssociatedTransferSettingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAssociatedTransferSettingResult::~ListAssociatedTransferSettingResult()
+{}
+
+void ListAssociatedTransferSettingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto associatedTransferSettingNode = value["AssociatedTransferSetting"];
+	if(!associatedTransferSettingNode["AccountId"].isNull())
+		associatedTransferSetting_.accountId = associatedTransferSettingNode["AccountId"].asString();
+	if(!associatedTransferSettingNode["Status"].isNull())
+		associatedTransferSetting_.status = associatedTransferSettingNode["Status"].asString();
+	if(!associatedTransferSettingNode["EnablePartialRule"].isNull())
+		associatedTransferSetting_.enablePartialRule = associatedTransferSettingNode["EnablePartialRule"].asString();
+	if(!associatedTransferSettingNode["EnableExistingResourcesTransfer"].isNull())
+		associatedTransferSetting_.enableExistingResourcesTransfer = associatedTransferSettingNode["EnableExistingResourcesTransfer"].asString();
+	auto allRuleSettingsNode = associatedTransferSettingNode["RuleSettings"]["RuleSetting"];
+	for (auto associatedTransferSettingNodeRuleSettingsRuleSetting : allRuleSettingsNode)
+	{
+		AssociatedTransferSetting::RuleSetting ruleSettingObject;
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedResourceType"].isNull())
+			ruleSettingObject.associatedResourceType = associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedResourceType"].asString();
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["MasterResourceType"].isNull())
+			ruleSettingObject.masterResourceType = associatedTransferSettingNodeRuleSettingsRuleSetting["MasterResourceType"].asString();
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedService"].isNull())
+			ruleSettingObject.associatedService = associatedTransferSettingNodeRuleSettingsRuleSetting["AssociatedService"].asString();
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["MasterService"].isNull())
+			ruleSettingObject.masterService = associatedTransferSettingNodeRuleSettingsRuleSetting["MasterService"].asString();
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["TriggerType"].isNull())
+			ruleSettingObject.triggerType = associatedTransferSettingNodeRuleSettingsRuleSetting["TriggerType"].asString();
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["RuleId"].isNull())
+			ruleSettingObject.ruleId = associatedTransferSettingNodeRuleSettingsRuleSetting["RuleId"].asString();
+		if(!associatedTransferSettingNodeRuleSettingsRuleSetting["Status"].isNull())
+			ruleSettingObject.status = associatedTransferSettingNodeRuleSettingsRuleSetting["Status"].asString();
+		associatedTransferSetting_.ruleSettings.push_back(ruleSettingObject);
+	}
+
+}
+
+ListAssociatedTransferSettingResult::AssociatedTransferSetting ListAssociatedTransferSettingResult::getAssociatedTransferSetting()const
+{
+	return associatedTransferSetting_;
+}
+

resourcemanager/src/model/ListAutoGroupingRulesRequest.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/resourcemanager/model/ListAutoGroupingRulesRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::ListAutoGroupingRulesRequest;
+
+ListAutoGroupingRulesRequest::ListAutoGroupingRulesRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "ListAutoGroupingRules") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListAutoGroupingRulesRequest::~ListAutoGroupingRulesRequest() {}
+
+std::string ListAutoGroupingRulesRequest::getRuleName() const {
+  return ruleName_;
+}
+
+void ListAutoGroupingRulesRequest::setRuleName(const std::string &ruleName) {
+  ruleName_ = ruleName;
+  setParameter(std::string("RuleName"), ruleName);
+}
+
+std::string ListAutoGroupingRulesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListAutoGroupingRulesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListAutoGroupingRulesRequest::getRuleType() const {
+  return ruleType_;
+}
+
+void ListAutoGroupingRulesRequest::setRuleType(const std::string &ruleType) {
+  ruleType_ = ruleType;
+  setParameter(std::string("RuleType"), ruleType);
+}
+
+int ListAutoGroupingRulesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListAutoGroupingRulesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string ListAutoGroupingRulesRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void ListAutoGroupingRulesRequest::setRuleId(const std::string &ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), ruleId);
+}
+

resourcemanager/src/model/ListAutoGroupingRulesResult.cc

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/ListAutoGroupingRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+ListAutoGroupingRulesResult::ListAutoGroupingRulesResult() :
+	ServiceResult()
+{}
+
+ListAutoGroupingRulesResult::ListAutoGroupingRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAutoGroupingRulesResult::~ListAutoGroupingRulesResult()
+{}
+
+void ListAutoGroupingRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRulesNode = value["Rules"]["Rule"];
+	for (auto valueRulesRule : allRulesNode)
+	{
+		Rule rulesObject;
+		if(!valueRulesRule["CreateTime"].isNull())
+			rulesObject.createTime = valueRulesRule["CreateTime"].asString();
+		if(!valueRulesRule["ExcludeRegionIdsScope"].isNull())
+			rulesObject.excludeRegionIdsScope = valueRulesRule["ExcludeRegionIdsScope"].asString();
+		if(!valueRulesRule["ExcludeResourceGroupIdsScope"].isNull())
+			rulesObject.excludeResourceGroupIdsScope = valueRulesRule["ExcludeResourceGroupIdsScope"].asString();
+		if(!valueRulesRule["ExcludeResourceIdsScope"].isNull())
+			rulesObject.excludeResourceIdsScope = valueRulesRule["ExcludeResourceIdsScope"].asString();
+		if(!valueRulesRule["ExcludeResourceTypesScope"].isNull())
+			rulesObject.excludeResourceTypesScope = valueRulesRule["ExcludeResourceTypesScope"].asString();
+		if(!valueRulesRule["ModifyTime"].isNull())
+			rulesObject.modifyTime = valueRulesRule["ModifyTime"].asString();
+		if(!valueRulesRule["RegionIdsScope"].isNull())
+			rulesObject.regionIdsScope = valueRulesRule["RegionIdsScope"].asString();
+		if(!valueRulesRule["ResourceGroupIdsScope"].isNull())
+			rulesObject.resourceGroupIdsScope = valueRulesRule["ResourceGroupIdsScope"].asString();
+		if(!valueRulesRule["ResourceIdsScope"].isNull())
+			rulesObject.resourceIdsScope = valueRulesRule["ResourceIdsScope"].asString();
+		if(!valueRulesRule["ResourceTypesScope"].isNull())
+			rulesObject.resourceTypesScope = valueRulesRule["ResourceTypesScope"].asString();
+		if(!valueRulesRule["RuleDesc"].isNull())
+			rulesObject.ruleDesc = valueRulesRule["RuleDesc"].asString();
+		if(!valueRulesRule["RuleId"].isNull())
+			rulesObject.ruleId = valueRulesRule["RuleId"].asString();
+		if(!valueRulesRule["RuleName"].isNull())
+			rulesObject.ruleName = valueRulesRule["RuleName"].asString();
+		if(!valueRulesRule["RuleType"].isNull())
+			rulesObject.ruleType = valueRulesRule["RuleType"].asString();
+		auto allRuleContentsNode = valueRulesRule["RuleContents"]["RuleContent"];
+		for (auto valueRulesRuleRuleContentsRuleContent : allRuleContentsNode)
+		{
+			Rule::RuleContent ruleContentsObject;
+			if(!valueRulesRuleRuleContentsRuleContent["AutoGroupingScopeCondition"].isNull())
+				ruleContentsObject.autoGroupingScopeCondition = valueRulesRuleRuleContentsRuleContent["AutoGroupingScopeCondition"].asString();
+			if(!valueRulesRuleRuleContentsRuleContent["RuleContentId"].isNull())
+				ruleContentsObject.ruleContentId = valueRulesRuleRuleContentsRuleContent["RuleContentId"].asString();
+			if(!valueRulesRuleRuleContentsRuleContent["TargetResourceGroupCondition"].isNull())
+				ruleContentsObject.targetResourceGroupCondition = valueRulesRuleRuleContentsRuleContent["TargetResourceGroupCondition"].asString();
+			rulesObject.ruleContents.push_back(ruleContentsObject);
+		}
+		rules_.push_back(rulesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+
+}
+
+std::string ListAutoGroupingRulesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int ListAutoGroupingRulesResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<ListAutoGroupingRulesResult::Rule> ListAutoGroupingRulesResult::getRules()const
+{
+	return rules_;
+}
+

resourcemanager/src/model/ListPoliciesResult.cc

@@ -43,28 +43,28 @@ void ListPoliciesResult::parse(const std::string &payload)
 	for (auto valuePoliciesPolicy : allPoliciesNode)
 	{
 		Policy policiesObject;
+		if(!valuePoliciesPolicy["AttachmentCount"].isNull())
+			policiesObject.attachmentCount = std::stoi(valuePoliciesPolicy["AttachmentCount"].asString());
+		if(!valuePoliciesPolicy["CreateDate"].isNull())
+			policiesObject.createDate = valuePoliciesPolicy["CreateDate"].asString();
 		if(!valuePoliciesPolicy["DefaultVersion"].isNull())
 			policiesObject.defaultVersion = valuePoliciesPolicy["DefaultVersion"].asString();
 		if(!valuePoliciesPolicy["Description"].isNull())
 			policiesObject.description = valuePoliciesPolicy["Description"].asString();
-		if(!valuePoliciesPolicy["UpdateDate"].isNull())
-			policiesObject.updateDate = valuePoliciesPolicy["UpdateDate"].asString();
-		if(!valuePoliciesPolicy["AttachmentCount"].isNull())
-			policiesObject.attachmentCount = std::stoi(valuePoliciesPolicy["AttachmentCount"].asString());
 		if(!valuePoliciesPolicy["PolicyName"].isNull())
 			policiesObject.policyName = valuePoliciesPolicy["PolicyName"].asString();
-		if(!valuePoliciesPolicy["CreateDate"].isNull())
-			policiesObject.createDate = valuePoliciesPolicy["CreateDate"].asString();
 		if(!valuePoliciesPolicy["PolicyType"].isNull())
 			policiesObject.policyType = valuePoliciesPolicy["PolicyType"].asString();
+		if(!valuePoliciesPolicy["UpdateDate"].isNull())
+			policiesObject.updateDate = valuePoliciesPolicy["UpdateDate"].asString();
 		policies_.push_back(policiesObject);
 	}
-	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());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 

resourcemanager/src/model/ListPolicyAttachmentsResult.cc

@@ -43,28 +43,28 @@ void ListPolicyAttachmentsResult::parse(const std::string &payload)
 	for (auto valuePolicyAttachmentsPolicyAttachment : allPolicyAttachmentsNode)
 	{
 		PolicyAttachment policyAttachmentsObject;
+		if(!valuePolicyAttachmentsPolicyAttachment["AttachDate"].isNull())
+			policyAttachmentsObject.attachDate = valuePolicyAttachmentsPolicyAttachment["AttachDate"].asString();
 		if(!valuePolicyAttachmentsPolicyAttachment["Description"].isNull())
 			policyAttachmentsObject.description = valuePolicyAttachmentsPolicyAttachment["Description"].asString();
-		if(!valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].isNull())
-			policyAttachmentsObject.resourceGroupId = valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].asString();
 		if(!valuePolicyAttachmentsPolicyAttachment["PolicyName"].isNull())
 			policyAttachmentsObject.policyName = valuePolicyAttachmentsPolicyAttachment["PolicyName"].asString();
-		if(!valuePolicyAttachmentsPolicyAttachment["PrincipalName"].isNull())
-			policyAttachmentsObject.principalName = valuePolicyAttachmentsPolicyAttachment["PrincipalName"].asString();
-		if(!valuePolicyAttachmentsPolicyAttachment["AttachDate"].isNull())
-			policyAttachmentsObject.attachDate = valuePolicyAttachmentsPolicyAttachment["AttachDate"].asString();
 		if(!valuePolicyAttachmentsPolicyAttachment["PolicyType"].isNull())
 			policyAttachmentsObject.policyType = valuePolicyAttachmentsPolicyAttachment["PolicyType"].asString();
+		if(!valuePolicyAttachmentsPolicyAttachment["PrincipalName"].isNull())
+			policyAttachmentsObject.principalName = valuePolicyAttachmentsPolicyAttachment["PrincipalName"].asString();
 		if(!valuePolicyAttachmentsPolicyAttachment["PrincipalType"].isNull())
 			policyAttachmentsObject.principalType = valuePolicyAttachmentsPolicyAttachment["PrincipalType"].asString();
+		if(!valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].isNull())
+			policyAttachmentsObject.resourceGroupId = valuePolicyAttachmentsPolicyAttachment["ResourceGroupId"].asString();
 		policyAttachments_.push_back(policyAttachmentsObject);
 	}
-	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());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 

resourcemanager/src/model/ListPolicyVersionsResult.cc

@@ -43,12 +43,12 @@ void ListPolicyVersionsResult::parse(const std::string &payload)
 	for (auto valuePolicyVersionsPolicyVersion : allPolicyVersionsNode)
 	{
 		PolicyVersion policyVersionsObject;
+		if(!valuePolicyVersionsPolicyVersion["CreateDate"].isNull())
+			policyVersionsObject.createDate = valuePolicyVersionsPolicyVersion["CreateDate"].asString();
 		if(!valuePolicyVersionsPolicyVersion["IsDefaultVersion"].isNull())
 			policyVersionsObject.isDefaultVersion = valuePolicyVersionsPolicyVersion["IsDefaultVersion"].asString() == "true";
 		if(!valuePolicyVersionsPolicyVersion["VersionId"].isNull())
 			policyVersionsObject.versionId = valuePolicyVersionsPolicyVersion["VersionId"].asString();
-		if(!valuePolicyVersionsPolicyVersion["CreateDate"].isNull())
-			policyVersionsObject.createDate = valuePolicyVersionsPolicyVersion["CreateDate"].asString();
 		policyVersions_.push_back(policyVersionsObject);
 	}
 

resourcemanager/src/model/ListRolesResult.cc

@@ -43,37 +43,37 @@ void ListRolesResult::parse(const std::string &payload)
 	for (auto valueRolesRole : allRolesNode)
 	{
 		Role rolesObject;
-		if(!valueRolesRole["RolePrincipalName"].isNull())
-			rolesObject.rolePrincipalName = valueRolesRole["RolePrincipalName"].asString();
-		if(!valueRolesRole["UpdateDate"].isNull())
-			rolesObject.updateDate = valueRolesRole["UpdateDate"].asString();
+		if(!valueRolesRole["Arn"].isNull())
+			rolesObject.arn = valueRolesRole["Arn"].asString();
+		if(!valueRolesRole["CreateDate"].isNull())
+			rolesObject.createDate = valueRolesRole["CreateDate"].asString();
 		if(!valueRolesRole["Description"].isNull())
 			rolesObject.description = valueRolesRole["Description"].asString();
+		if(!valueRolesRole["IsServiceLinkedRole"].isNull())
+			rolesObject.isServiceLinkedRole = valueRolesRole["IsServiceLinkedRole"].asString() == "true";
 		if(!valueRolesRole["MaxSessionDuration"].isNull())
 			rolesObject.maxSessionDuration = std::stol(valueRolesRole["MaxSessionDuration"].asString());
-		if(!valueRolesRole["RoleName"].isNull())
-			rolesObject.roleName = valueRolesRole["RoleName"].asString();
-		if(!valueRolesRole["CreateDate"].isNull())
-			rolesObject.createDate = valueRolesRole["CreateDate"].asString();
 		if(!valueRolesRole["RoleId"].isNull())
 			rolesObject.roleId = valueRolesRole["RoleId"].asString();
-		if(!valueRolesRole["Arn"].isNull())
-			rolesObject.arn = valueRolesRole["Arn"].asString();
-		if(!valueRolesRole["IsServiceLinkedRole"].isNull())
-			rolesObject.isServiceLinkedRole = valueRolesRole["IsServiceLinkedRole"].asString() == "true";
+		if(!valueRolesRole["RoleName"].isNull())
+			rolesObject.roleName = valueRolesRole["RoleName"].asString();
+		if(!valueRolesRole["RolePrincipalName"].isNull())
+			rolesObject.rolePrincipalName = valueRolesRole["RolePrincipalName"].asString();
+		if(!valueRolesRole["UpdateDate"].isNull())
+			rolesObject.updateDate = valueRolesRole["UpdateDate"].asString();
 		auto latestDeletionTaskNode = value["LatestDeletionTask"];
-		if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
-			rolesObject.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
 		if(!latestDeletionTaskNode["CreateDate"].isNull())
 			rolesObject.latestDeletionTask.createDate = latestDeletionTaskNode["CreateDate"].asString();
+		if(!latestDeletionTaskNode["DeletionTaskId"].isNull())
+			rolesObject.latestDeletionTask.deletionTaskId = latestDeletionTaskNode["DeletionTaskId"].asString();
 		roles_.push_back(rolesObject);
 	}
-	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());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 

resourcemanager/src/model/ListTagResourcesRequest.cc

@@ -25,6 +25,27 @@ ListTagResourcesRequest::ListTagResourcesRequest()
 
 ListTagResourcesRequest::~ListTagResourcesRequest() {}
 
+std::string ListTagResourcesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListTagResourcesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag() const {
+  return tag_;
+}
+
+void ListTagResourcesRequest::setTag(const std::vector<ListTagResourcesRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
+    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
+  }
+}
+
 std::vector<ListTagResourcesRequest::std::string> ListTagResourcesRequest::getResourceId() const {
   return resourceId_;
 }
@@ -45,15 +66,6 @@ void ListTagResourcesRequest::setResourceType(const std::string &resourceType) {
   setParameter(std::string("ResourceType"), resourceType);
 }
 
-std::string ListTagResourcesRequest::getNextToken() const {
-  return nextToken_;
-}
-
-void ListTagResourcesRequest::setNextToken(const std::string &nextToken) {
-  nextToken_ = nextToken;
-  setParameter(std::string("NextToken"), nextToken);
-}
-
 int ListTagResourcesRequest::getMaxResults() const {
   return maxResults_;
 }
@@ -63,15 +75,3 @@ void ListTagResourcesRequest::setMaxResults(int maxResults) {
   setParameter(std::string("MaxResults"), std::to_string(maxResults));
 }
 
-std::vector<ListTagResourcesRequest::Tag> ListTagResourcesRequest::getTag() const {
-  return tag_;
-}
-
-void ListTagResourcesRequest::setTag(const std::vector<ListTagResourcesRequest::Tag> &tag) {
-  tag_ = tag;
-  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
-    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Value", tag[dep1].value);
-    setParameter(std::string("Tag") + "." + std::to_string(dep1 + 1) + ".Key", tag[dep1].key);
-  }
-}
-

resourcemanager/src/model/PromoteResourceAccountResult.cc

@@ -40,28 +40,28 @@ void PromoteResourceAccountResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto accountNode = value["Account"];
-	if(!accountNode["Status"].isNull())
-		account_.status = accountNode["Status"].asString();
-	if(!accountNode["Type"].isNull())
-		account_.type = accountNode["Type"].asString();
+	if(!accountNode["AccountId"].isNull())
+		account_.accountId = accountNode["AccountId"].asString();
+	if(!accountNode["AccountName"].isNull())
+		account_.accountName = accountNode["AccountName"].asString();
 	if(!accountNode["DisplayName"].isNull())
 		account_.displayName = accountNode["DisplayName"].asString();
 	if(!accountNode["FolderId"].isNull())
 		account_.folderId = accountNode["FolderId"].asString();
-	if(!accountNode["ResourceDirectoryId"].isNull())
-		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
-	if(!accountNode["RecordId"].isNull())
-		account_.recordId = accountNode["RecordId"].asString();
-	if(!accountNode["JoinTime"].isNull())
-		account_.joinTime = accountNode["JoinTime"].asString();
-	if(!accountNode["AccountId"].isNull())
-		account_.accountId = accountNode["AccountId"].asString();
 	if(!accountNode["JoinMethod"].isNull())
 		account_.joinMethod = accountNode["JoinMethod"].asString();
-	if(!accountNode["AccountName"].isNull())
-		account_.accountName = accountNode["AccountName"].asString();
+	if(!accountNode["JoinTime"].isNull())
+		account_.joinTime = accountNode["JoinTime"].asString();
 	if(!accountNode["ModifyTime"].isNull())
 		account_.modifyTime = accountNode["ModifyTime"].asString();
+	if(!accountNode["RecordId"].isNull())
+		account_.recordId = accountNode["RecordId"].asString();
+	if(!accountNode["ResourceDirectoryId"].isNull())
+		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
+	if(!accountNode["Status"].isNull())
+		account_.status = accountNode["Status"].asString();
+	if(!accountNode["Type"].isNull())
+		account_.type = accountNode["Type"].asString();
 
 }
 

resourcemanager/src/model/ResendCreateCloudAccountEmailResult.cc

@@ -40,28 +40,28 @@ void ResendCreateCloudAccountEmailResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto accountNode = value["Account"];
-	if(!accountNode["Status"].isNull())
-		account_.status = accountNode["Status"].asString();
-	if(!accountNode["Type"].isNull())
-		account_.type = accountNode["Type"].asString();
+	if(!accountNode["AccountId"].isNull())
+		account_.accountId = accountNode["AccountId"].asString();
+	if(!accountNode["AccountName"].isNull())
+		account_.accountName = accountNode["AccountName"].asString();
 	if(!accountNode["DisplayName"].isNull())
 		account_.displayName = accountNode["DisplayName"].asString();
 	if(!accountNode["FolderId"].isNull())
 		account_.folderId = accountNode["FolderId"].asString();
-	if(!accountNode["ResourceDirectoryId"].isNull())
-		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
-	if(!accountNode["RecordId"].isNull())
-		account_.recordId = accountNode["RecordId"].asString();
-	if(!accountNode["JoinTime"].isNull())
-		account_.joinTime = accountNode["JoinTime"].asString();
-	if(!accountNode["AccountId"].isNull())
-		account_.accountId = accountNode["AccountId"].asString();
 	if(!accountNode["JoinMethod"].isNull())
 		account_.joinMethod = accountNode["JoinMethod"].asString();
-	if(!accountNode["AccountName"].isNull())
-		account_.accountName = accountNode["AccountName"].asString();
+	if(!accountNode["JoinTime"].isNull())
+		account_.joinTime = accountNode["JoinTime"].asString();
 	if(!accountNode["ModifyTime"].isNull())
 		account_.modifyTime = accountNode["ModifyTime"].asString();
+	if(!accountNode["RecordId"].isNull())
+		account_.recordId = accountNode["RecordId"].asString();
+	if(!accountNode["ResourceDirectoryId"].isNull())
+		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
+	if(!accountNode["Status"].isNull())
+		account_.status = accountNode["Status"].asString();
+	if(!accountNode["Type"].isNull())
+		account_.type = accountNode["Type"].asString();
 
 }
 

resourcemanager/src/model/ResendPromoteResourceAccountEmailResult.cc

@@ -40,28 +40,28 @@ void ResendPromoteResourceAccountEmailResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto accountNode = value["Account"];
-	if(!accountNode["Status"].isNull())
-		account_.status = accountNode["Status"].asString();
-	if(!accountNode["Type"].isNull())
-		account_.type = accountNode["Type"].asString();
+	if(!accountNode["AccountId"].isNull())
+		account_.accountId = accountNode["AccountId"].asString();
+	if(!accountNode["AccountName"].isNull())
+		account_.accountName = accountNode["AccountName"].asString();
 	if(!accountNode["DisplayName"].isNull())
 		account_.displayName = accountNode["DisplayName"].asString();
 	if(!accountNode["FolderId"].isNull())
 		account_.folderId = accountNode["FolderId"].asString();
-	if(!accountNode["ResourceDirectoryId"].isNull())
-		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
-	if(!accountNode["RecordId"].isNull())
-		account_.recordId = accountNode["RecordId"].asString();
-	if(!accountNode["JoinTime"].isNull())
-		account_.joinTime = accountNode["JoinTime"].asString();
-	if(!accountNode["AccountId"].isNull())
-		account_.accountId = accountNode["AccountId"].asString();
 	if(!accountNode["JoinMethod"].isNull())
 		account_.joinMethod = accountNode["JoinMethod"].asString();
-	if(!accountNode["AccountName"].isNull())
-		account_.accountName = accountNode["AccountName"].asString();
+	if(!accountNode["JoinTime"].isNull())
+		account_.joinTime = accountNode["JoinTime"].asString();
 	if(!accountNode["ModifyTime"].isNull())
 		account_.modifyTime = accountNode["ModifyTime"].asString();
+	if(!accountNode["RecordId"].isNull())
+		account_.recordId = accountNode["RecordId"].asString();
+	if(!accountNode["ResourceDirectoryId"].isNull())
+		account_.resourceDirectoryId = accountNode["ResourceDirectoryId"].asString();
+	if(!accountNode["Status"].isNull())
+		account_.status = accountNode["Status"].asString();
+	if(!accountNode["Type"].isNull())
+		account_.type = accountNode["Type"].asString();
 
 }
 

resourcemanager/src/model/UpdateAssociatedTransferSettingRequest.cc

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/UpdateAssociatedTransferSettingRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::UpdateAssociatedTransferSettingRequest;
+
+UpdateAssociatedTransferSettingRequest::UpdateAssociatedTransferSettingRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAssociatedTransferSetting") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAssociatedTransferSettingRequest::~UpdateAssociatedTransferSettingRequest() {}
+
+std::vector<UpdateAssociatedTransferSettingRequest::RuleSettings> UpdateAssociatedTransferSettingRequest::getRuleSettings() const {
+  return ruleSettings_;
+}
+
+void UpdateAssociatedTransferSettingRequest::setRuleSettings(const std::vector<UpdateAssociatedTransferSettingRequest::RuleSettings> &ruleSettings) {
+  ruleSettings_ = ruleSettings;
+  for(int dep1 = 0; dep1 != ruleSettings.size(); dep1++) {
+    setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".AssociatedService", ruleSettings[dep1].associatedService);
+    setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".MasterService", ruleSettings[dep1].masterService);
+    setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".MasterResourceType", ruleSettings[dep1].masterResourceType);
+    setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".AssociatedResourceType", ruleSettings[dep1].associatedResourceType);
+    setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".RuleId", ruleSettings[dep1].ruleId);
+    setParameter(std::string("RuleSettings") + "." + std::to_string(dep1 + 1) + ".Status", ruleSettings[dep1].status);
+  }
+}
+
+std::string UpdateAssociatedTransferSettingRequest::getEnableExistingResourcesTransfer() const {
+  return enableExistingResourcesTransfer_;
+}
+
+void UpdateAssociatedTransferSettingRequest::setEnableExistingResourcesTransfer(const std::string &enableExistingResourcesTransfer) {
+  enableExistingResourcesTransfer_ = enableExistingResourcesTransfer;
+  setParameter(std::string("EnableExistingResourcesTransfer"), enableExistingResourcesTransfer);
+}
+

resourcemanager/src/model/UpdateAssociatedTransferSettingResult.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/resourcemanager/model/UpdateAssociatedTransferSettingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+UpdateAssociatedTransferSettingResult::UpdateAssociatedTransferSettingResult() :
+	ServiceResult()
+{}
+
+UpdateAssociatedTransferSettingResult::UpdateAssociatedTransferSettingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateAssociatedTransferSettingResult::~UpdateAssociatedTransferSettingResult()
+{}
+
+void UpdateAssociatedTransferSettingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/UpdateAutoGroupingConfigRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/UpdateAutoGroupingConfigRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::UpdateAutoGroupingConfigRequest;
+
+UpdateAutoGroupingConfigRequest::UpdateAutoGroupingConfigRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAutoGroupingConfig") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAutoGroupingConfigRequest::~UpdateAutoGroupingConfigRequest() {}
+
+bool UpdateAutoGroupingConfigRequest::getEnableExistingResourcesTransfer() const {
+  return enableExistingResourcesTransfer_;
+}
+
+void UpdateAutoGroupingConfigRequest::setEnableExistingResourcesTransfer(bool enableExistingResourcesTransfer) {
+  enableExistingResourcesTransfer_ = enableExistingResourcesTransfer;
+  setParameter(std::string("EnableExistingResourcesTransfer"), enableExistingResourcesTransfer ? "true" : "false");
+}
+

resourcemanager/src/model/UpdateAutoGroupingConfigResult.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/resourcemanager/model/UpdateAutoGroupingConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+UpdateAutoGroupingConfigResult::UpdateAutoGroupingConfigResult() :
+	ServiceResult()
+{}
+
+UpdateAutoGroupingConfigResult::UpdateAutoGroupingConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateAutoGroupingConfigResult::~UpdateAutoGroupingConfigResult()
+{}
+
+void UpdateAutoGroupingConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/UpdateAutoGroupingRuleRequest.cc

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcemanager/model/UpdateAutoGroupingRuleRequest.h>
+
+using AlibabaCloud::ResourceManager::Model::UpdateAutoGroupingRuleRequest;
+
+UpdateAutoGroupingRuleRequest::UpdateAutoGroupingRuleRequest()
+    : RpcServiceRequest("resourcemanager", "2020-03-31", "UpdateAutoGroupingRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAutoGroupingRuleRequest::~UpdateAutoGroupingRuleRequest() {}
+
+std::string UpdateAutoGroupingRuleRequest::getRuleDesc() const {
+  return ruleDesc_;
+}
+
+void UpdateAutoGroupingRuleRequest::setRuleDesc(const std::string &ruleDesc) {
+  ruleDesc_ = ruleDesc;
+  setParameter(std::string("RuleDesc"), ruleDesc);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getResourceTypesScope() const {
+  return resourceTypesScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setResourceTypesScope(const std::string &resourceTypesScope) {
+  resourceTypesScope_ = resourceTypesScope;
+  setParameter(std::string("ResourceTypesScope"), resourceTypesScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getRuleName() const {
+  return ruleName_;
+}
+
+void UpdateAutoGroupingRuleRequest::setRuleName(const std::string &ruleName) {
+  ruleName_ = ruleName;
+  setParameter(std::string("RuleName"), ruleName);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getExcludeResourceGroupIdsScope() const {
+  return excludeResourceGroupIdsScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setExcludeResourceGroupIdsScope(const std::string &excludeResourceGroupIdsScope) {
+  excludeResourceGroupIdsScope_ = excludeResourceGroupIdsScope;
+  setParameter(std::string("ExcludeResourceGroupIdsScope"), excludeResourceGroupIdsScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getRegionIdsScope() const {
+  return regionIdsScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setRegionIdsScope(const std::string &regionIdsScope) {
+  regionIdsScope_ = regionIdsScope;
+  setParameter(std::string("RegionIdsScope"), regionIdsScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getResourceIdsScope() const {
+  return resourceIdsScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setResourceIdsScope(const std::string &resourceIdsScope) {
+  resourceIdsScope_ = resourceIdsScope;
+  setParameter(std::string("ResourceIdsScope"), resourceIdsScope);
+}
+
+std::vector<UpdateAutoGroupingRuleRequest::RuleContents> UpdateAutoGroupingRuleRequest::getRuleContents() const {
+  return ruleContents_;
+}
+
+void UpdateAutoGroupingRuleRequest::setRuleContents(const std::vector<UpdateAutoGroupingRuleRequest::RuleContents> &ruleContents) {
+  ruleContents_ = ruleContents;
+  for(int dep1 = 0; dep1 != ruleContents.size(); dep1++) {
+  auto ruleContentsObj = ruleContents.at(dep1);
+  std::string ruleContentsObjStr = std::string("RuleContents") + "." + std::to_string(dep1 + 1);
+    setParameter(ruleContentsObjStr + ".RuleContentId", ruleContentsObj.ruleContentId);
+    setParameter(ruleContentsObjStr + ".TargetResourceGroupCondition", ruleContentsObj.targetResourceGroupCondition);
+    setParameter(ruleContentsObjStr + ".AutoGroupingScopeCondition", ruleContentsObj.autoGroupingScopeCondition);
+  }
+}
+
+std::string UpdateAutoGroupingRuleRequest::getExcludeResourceTypesScope() const {
+  return excludeResourceTypesScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setExcludeResourceTypesScope(const std::string &excludeResourceTypesScope) {
+  excludeResourceTypesScope_ = excludeResourceTypesScope;
+  setParameter(std::string("ExcludeResourceTypesScope"), excludeResourceTypesScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getResourceGroupIdsScope() const {
+  return resourceGroupIdsScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setResourceGroupIdsScope(const std::string &resourceGroupIdsScope) {
+  resourceGroupIdsScope_ = resourceGroupIdsScope;
+  setParameter(std::string("ResourceGroupIdsScope"), resourceGroupIdsScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getExcludeRegionIdsScope() const {
+  return excludeRegionIdsScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setExcludeRegionIdsScope(const std::string &excludeRegionIdsScope) {
+  excludeRegionIdsScope_ = excludeRegionIdsScope;
+  setParameter(std::string("ExcludeRegionIdsScope"), excludeRegionIdsScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getExcludeResourceIdsScope() const {
+  return excludeResourceIdsScope_;
+}
+
+void UpdateAutoGroupingRuleRequest::setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope) {
+  excludeResourceIdsScope_ = excludeResourceIdsScope;
+  setParameter(std::string("ExcludeResourceIdsScope"), excludeResourceIdsScope);
+}
+
+std::string UpdateAutoGroupingRuleRequest::getRuleId() const {
+  return ruleId_;
+}
+
+void UpdateAutoGroupingRuleRequest::setRuleId(const std::string &ruleId) {
+  ruleId_ = ruleId;
+  setParameter(std::string("RuleId"), ruleId);
+}
+

resourcemanager/src/model/UpdateAutoGroupingRuleResult.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/resourcemanager/model/UpdateAutoGroupingRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceManager;
+using namespace AlibabaCloud::ResourceManager::Model;
+
+UpdateAutoGroupingRuleResult::UpdateAutoGroupingRuleResult() :
+	ServiceResult()
+{}
+
+UpdateAutoGroupingRuleResult::UpdateAutoGroupingRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateAutoGroupingRuleResult::~UpdateAutoGroupingRuleResult()
+{}
+
+void UpdateAutoGroupingRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

resourcemanager/src/model/UpdateRoleResult.cc

@@ -40,24 +40,24 @@ void UpdateRoleResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	auto roleNode = value["Role"];
+	if(!roleNode["Arn"].isNull())
+		role_.arn = roleNode["Arn"].asString();
 	if(!roleNode["AssumeRolePolicyDocument"].isNull())
 		role_.assumeRolePolicyDocument = roleNode["AssumeRolePolicyDocument"].asString();
-	if(!roleNode["RolePrincipalName"].isNull())
-		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
+	if(!roleNode["CreateDate"].isNull())
+		role_.createDate = roleNode["CreateDate"].asString();
 	if(!roleNode["Description"].isNull())
 		role_.description = roleNode["Description"].asString();
-	if(!roleNode["UpdateDate"].isNull())
-		role_.updateDate = roleNode["UpdateDate"].asString();
 	if(!roleNode["MaxSessionDuration"].isNull())
 		role_.maxSessionDuration = std::stol(roleNode["MaxSessionDuration"].asString());
-	if(!roleNode["RoleName"].isNull())
-		role_.roleName = roleNode["RoleName"].asString();
-	if(!roleNode["CreateDate"].isNull())
-		role_.createDate = roleNode["CreateDate"].asString();
 	if(!roleNode["RoleId"].isNull())
 		role_.roleId = roleNode["RoleId"].asString();
-	if(!roleNode["Arn"].isNull())
-		role_.arn = roleNode["Arn"].asString();
+	if(!roleNode["RoleName"].isNull())
+		role_.roleName = roleNode["RoleName"].asString();
+	if(!roleNode["RolePrincipalName"].isNull())
+		role_.rolePrincipalName = roleNode["RolePrincipalName"].asString();
+	if(!roleNode["UpdateDate"].isNull())
+		role_.updateDate = roleNode["UpdateDate"].asString();
 
 }