Support managed rule query.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-12-28 Version: 1.36.999
+- Support managed rule query.
+
 2021-12-27 Version: 1.36.998
 - Support ACR EE, OSS, EIP for deploy.
 

VERSION

@@ -1 +1 @@
-1.36.998
+1.36.999

config/CMakeLists.txt

@@ -79,6 +79,10 @@ set(config_public_header_model
 	include/alibabacloud/config/model/GetAggregateResourceComplianceByConfigRuleResult.h
 	include/alibabacloud/config/model/GetAggregateResourceComplianceByPackRequest.h
 	include/alibabacloud/config/model/GetAggregateResourceComplianceByPackResult.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionResult.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeResult.h
 	include/alibabacloud/config/model/GetAggregateResourceComplianceTimelineRequest.h
 	include/alibabacloud/config/model/GetAggregateResourceComplianceTimelineResult.h
 	include/alibabacloud/config/model/GetAggregateResourceConfigurationTimelineRequest.h
@@ -105,10 +109,16 @@ set(config_public_header_model
 	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByRegionResult.h
 	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.h
 	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByResourceTypeResult.h
+	include/alibabacloud/config/model/GetManagedRuleRequest.h
+	include/alibabacloud/config/model/GetManagedRuleResult.h
 	include/alibabacloud/config/model/GetResourceComplianceByConfigRuleRequest.h
 	include/alibabacloud/config/model/GetResourceComplianceByConfigRuleResult.h
 	include/alibabacloud/config/model/GetResourceComplianceByPackRequest.h
 	include/alibabacloud/config/model/GetResourceComplianceByPackResult.h
+	include/alibabacloud/config/model/GetResourceComplianceGroupByRegionRequest.h
+	include/alibabacloud/config/model/GetResourceComplianceGroupByRegionResult.h
+	include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeRequest.h
+	include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeResult.h
 	include/alibabacloud/config/model/GetResourceComplianceTimelineRequest.h
 	include/alibabacloud/config/model/GetResourceComplianceTimelineResult.h
 	include/alibabacloud/config/model/GetResourceConfigurationTimelineRequest.h
@@ -133,6 +143,8 @@ set(config_public_header_model
 	include/alibabacloud/config/model/ListCompliancePacksResult.h
 	include/alibabacloud/config/model/ListConfigRuleEvaluationResultsRequest.h
 	include/alibabacloud/config/model/ListConfigRuleEvaluationResultsResult.h
+	include/alibabacloud/config/model/ListManagedRulesRequest.h
+	include/alibabacloud/config/model/ListManagedRulesResult.h
 	include/alibabacloud/config/model/ListResourceEvaluationResultsRequest.h
 	include/alibabacloud/config/model/ListResourceEvaluationResultsResult.h
 	include/alibabacloud/config/model/RevertAggregateEvaluationResultsRequest.h
@@ -212,6 +224,10 @@ set(config_src
 	src/model/GetAggregateResourceComplianceByConfigRuleResult.cc
 	src/model/GetAggregateResourceComplianceByPackRequest.cc
 	src/model/GetAggregateResourceComplianceByPackResult.cc
+	src/model/GetAggregateResourceComplianceGroupByRegionRequest.cc
+	src/model/GetAggregateResourceComplianceGroupByRegionResult.cc
+	src/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.cc
+	src/model/GetAggregateResourceComplianceGroupByResourceTypeResult.cc
 	src/model/GetAggregateResourceComplianceTimelineRequest.cc
 	src/model/GetAggregateResourceComplianceTimelineResult.cc
 	src/model/GetAggregateResourceConfigurationTimelineRequest.cc
@@ -238,10 +254,16 @@ set(config_src
 	src/model/GetDiscoveredResourceCountsGroupByRegionResult.cc
 	src/model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.cc
 	src/model/GetDiscoveredResourceCountsGroupByResourceTypeResult.cc
+	src/model/GetManagedRuleRequest.cc
+	src/model/GetManagedRuleResult.cc
 	src/model/GetResourceComplianceByConfigRuleRequest.cc
 	src/model/GetResourceComplianceByConfigRuleResult.cc
 	src/model/GetResourceComplianceByPackRequest.cc
 	src/model/GetResourceComplianceByPackResult.cc
+	src/model/GetResourceComplianceGroupByRegionRequest.cc
+	src/model/GetResourceComplianceGroupByRegionResult.cc
+	src/model/GetResourceComplianceGroupByResourceTypeRequest.cc
+	src/model/GetResourceComplianceGroupByResourceTypeResult.cc
 	src/model/GetResourceComplianceTimelineRequest.cc
 	src/model/GetResourceComplianceTimelineResult.cc
 	src/model/GetResourceConfigurationTimelineRequest.cc
@@ -266,6 +288,8 @@ set(config_src
 	src/model/ListCompliancePacksResult.cc
 	src/model/ListConfigRuleEvaluationResultsRequest.cc
 	src/model/ListConfigRuleEvaluationResultsResult.cc
+	src/model/ListManagedRulesRequest.cc
+	src/model/ListManagedRulesResult.cc
 	src/model/ListResourceEvaluationResultsRequest.cc
 	src/model/ListResourceEvaluationResultsResult.cc
 	src/model/RevertAggregateEvaluationResultsRequest.cc

config/include/alibabacloud/config/ConfigClient.h

@@ -80,6 +80,10 @@
 #include "model/GetAggregateResourceComplianceByConfigRuleResult.h"
 #include "model/GetAggregateResourceComplianceByPackRequest.h"
 #include "model/GetAggregateResourceComplianceByPackResult.h"
+#include "model/GetAggregateResourceComplianceGroupByRegionRequest.h"
+#include "model/GetAggregateResourceComplianceGroupByRegionResult.h"
+#include "model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h"
+#include "model/GetAggregateResourceComplianceGroupByResourceTypeResult.h"
 #include "model/GetAggregateResourceComplianceTimelineRequest.h"
 #include "model/GetAggregateResourceComplianceTimelineResult.h"
 #include "model/GetAggregateResourceConfigurationTimelineRequest.h"
@@ -106,10 +110,16 @@
 #include "model/GetDiscoveredResourceCountsGroupByRegionResult.h"
 #include "model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.h"
 #include "model/GetDiscoveredResourceCountsGroupByResourceTypeResult.h"
+#include "model/GetManagedRuleRequest.h"
+#include "model/GetManagedRuleResult.h"
 #include "model/GetResourceComplianceByConfigRuleRequest.h"
 #include "model/GetResourceComplianceByConfigRuleResult.h"
 #include "model/GetResourceComplianceByPackRequest.h"
 #include "model/GetResourceComplianceByPackResult.h"
+#include "model/GetResourceComplianceGroupByRegionRequest.h"
+#include "model/GetResourceComplianceGroupByRegionResult.h"
+#include "model/GetResourceComplianceGroupByResourceTypeRequest.h"
+#include "model/GetResourceComplianceGroupByResourceTypeResult.h"
 #include "model/GetResourceComplianceTimelineRequest.h"
 #include "model/GetResourceComplianceTimelineResult.h"
 #include "model/GetResourceConfigurationTimelineRequest.h"
@@ -134,6 +144,8 @@
 #include "model/ListCompliancePacksResult.h"
 #include "model/ListConfigRuleEvaluationResultsRequest.h"
 #include "model/ListConfigRuleEvaluationResultsResult.h"
+#include "model/ListManagedRulesRequest.h"
+#include "model/ListManagedRulesResult.h"
 #include "model/ListResourceEvaluationResultsRequest.h"
 #include "model/ListResourceEvaluationResultsResult.h"
 #include "model/RevertAggregateEvaluationResultsRequest.h"
@@ -248,6 +260,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetAggregateResourceComplianceByPackResult> GetAggregateResourceComplianceByPackOutcome;
 			typedef std::future<GetAggregateResourceComplianceByPackOutcome> GetAggregateResourceComplianceByPackOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceByPackRequest&, const GetAggregateResourceComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceByPackAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceComplianceGroupByRegionResult> GetAggregateResourceComplianceGroupByRegionOutcome;
+			typedef std::future<GetAggregateResourceComplianceGroupByRegionOutcome> GetAggregateResourceComplianceGroupByRegionOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceGroupByRegionRequest&, const GetAggregateResourceComplianceGroupByRegionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceGroupByRegionAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceComplianceGroupByResourceTypeResult> GetAggregateResourceComplianceGroupByResourceTypeOutcome;
+			typedef std::future<GetAggregateResourceComplianceGroupByResourceTypeOutcome> GetAggregateResourceComplianceGroupByResourceTypeOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest&, const GetAggregateResourceComplianceGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceGroupByResourceTypeAsyncHandler;
 			typedef Outcome<Error, Model::GetAggregateResourceComplianceTimelineResult> GetAggregateResourceComplianceTimelineOutcome;
 			typedef std::future<GetAggregateResourceComplianceTimelineOutcome> GetAggregateResourceComplianceTimelineOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceTimelineRequest&, const GetAggregateResourceComplianceTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceTimelineAsyncHandler;
@@ -287,12 +305,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetDiscoveredResourceCountsGroupByResourceTypeResult> GetDiscoveredResourceCountsGroupByResourceTypeOutcome;
 			typedef std::future<GetDiscoveredResourceCountsGroupByResourceTypeOutcome> GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest&, const GetDiscoveredResourceCountsGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiscoveredResourceCountsGroupByResourceTypeAsyncHandler;
+			typedef Outcome<Error, Model::GetManagedRuleResult> GetManagedRuleOutcome;
+			typedef std::future<GetManagedRuleOutcome> GetManagedRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetManagedRuleRequest&, const GetManagedRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetManagedRuleAsyncHandler;
 			typedef Outcome<Error, Model::GetResourceComplianceByConfigRuleResult> GetResourceComplianceByConfigRuleOutcome;
 			typedef std::future<GetResourceComplianceByConfigRuleOutcome> GetResourceComplianceByConfigRuleOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceByConfigRuleRequest&, const GetResourceComplianceByConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceByConfigRuleAsyncHandler;
 			typedef Outcome<Error, Model::GetResourceComplianceByPackResult> GetResourceComplianceByPackOutcome;
 			typedef std::future<GetResourceComplianceByPackOutcome> GetResourceComplianceByPackOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceByPackRequest&, const GetResourceComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceByPackAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceComplianceGroupByRegionResult> GetResourceComplianceGroupByRegionOutcome;
+			typedef std::future<GetResourceComplianceGroupByRegionOutcome> GetResourceComplianceGroupByRegionOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceGroupByRegionRequest&, const GetResourceComplianceGroupByRegionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceGroupByRegionAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceComplianceGroupByResourceTypeResult> GetResourceComplianceGroupByResourceTypeOutcome;
+			typedef std::future<GetResourceComplianceGroupByResourceTypeOutcome> GetResourceComplianceGroupByResourceTypeOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceGroupByResourceTypeRequest&, const GetResourceComplianceGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceGroupByResourceTypeAsyncHandler;
 			typedef Outcome<Error, Model::GetResourceComplianceTimelineResult> GetResourceComplianceTimelineOutcome;
 			typedef std::future<GetResourceComplianceTimelineOutcome> GetResourceComplianceTimelineOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceTimelineRequest&, const GetResourceComplianceTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceTimelineAsyncHandler;
@@ -329,6 +356,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListConfigRuleEvaluationResultsResult> ListConfigRuleEvaluationResultsOutcome;
 			typedef std::future<ListConfigRuleEvaluationResultsOutcome> ListConfigRuleEvaluationResultsOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::ListConfigRuleEvaluationResultsRequest&, const ListConfigRuleEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConfigRuleEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::ListManagedRulesResult> ListManagedRulesOutcome;
+			typedef std::future<ListManagedRulesOutcome> ListManagedRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListManagedRulesRequest&, const ListManagedRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListManagedRulesAsyncHandler;
 			typedef Outcome<Error, Model::ListResourceEvaluationResultsResult> ListResourceEvaluationResultsOutcome;
 			typedef std::future<ListResourceEvaluationResultsOutcome> ListResourceEvaluationResultsOutcomeCallable;
 			typedef std::function<void(const ConfigClient*, const Model::ListResourceEvaluationResultsRequest&, const ListResourceEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceEvaluationResultsAsyncHandler;
@@ -448,6 +478,12 @@ namespace AlibabaCloud
 			GetAggregateResourceComplianceByPackOutcome getAggregateResourceComplianceByPack(const Model::GetAggregateResourceComplianceByPackRequest &request)const;
 			void getAggregateResourceComplianceByPackAsync(const Model::GetAggregateResourceComplianceByPackRequest& request, const GetAggregateResourceComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAggregateResourceComplianceByPackOutcomeCallable getAggregateResourceComplianceByPackCallable(const Model::GetAggregateResourceComplianceByPackRequest& request) const;
+			GetAggregateResourceComplianceGroupByRegionOutcome getAggregateResourceComplianceGroupByRegion(const Model::GetAggregateResourceComplianceGroupByRegionRequest &request)const;
+			void getAggregateResourceComplianceGroupByRegionAsync(const Model::GetAggregateResourceComplianceGroupByRegionRequest& request, const GetAggregateResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceComplianceGroupByRegionOutcomeCallable getAggregateResourceComplianceGroupByRegionCallable(const Model::GetAggregateResourceComplianceGroupByRegionRequest& request) const;
+			GetAggregateResourceComplianceGroupByResourceTypeOutcome getAggregateResourceComplianceGroupByResourceType(const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest &request)const;
+			void getAggregateResourceComplianceGroupByResourceTypeAsync(const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest& request, const GetAggregateResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceComplianceGroupByResourceTypeOutcomeCallable getAggregateResourceComplianceGroupByResourceTypeCallable(const Model::GetAggregateResourceComplianceGroupByResourceTypeRequest& request) const;
 			GetAggregateResourceComplianceTimelineOutcome getAggregateResourceComplianceTimeline(const Model::GetAggregateResourceComplianceTimelineRequest &request)const;
 			void getAggregateResourceComplianceTimelineAsync(const Model::GetAggregateResourceComplianceTimelineRequest& request, const GetAggregateResourceComplianceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAggregateResourceComplianceTimelineOutcomeCallable getAggregateResourceComplianceTimelineCallable(const Model::GetAggregateResourceComplianceTimelineRequest& request) const;
@@ -487,12 +523,21 @@ namespace AlibabaCloud
 			GetDiscoveredResourceCountsGroupByResourceTypeOutcome getDiscoveredResourceCountsGroupByResourceType(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest &request)const;
 			void getDiscoveredResourceCountsGroupByResourceTypeAsync(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest& request, const GetDiscoveredResourceCountsGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable getDiscoveredResourceCountsGroupByResourceTypeCallable(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest& request) const;
+			GetManagedRuleOutcome getManagedRule(const Model::GetManagedRuleRequest &request)const;
+			void getManagedRuleAsync(const Model::GetManagedRuleRequest& request, const GetManagedRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetManagedRuleOutcomeCallable getManagedRuleCallable(const Model::GetManagedRuleRequest& request) const;
 			GetResourceComplianceByConfigRuleOutcome getResourceComplianceByConfigRule(const Model::GetResourceComplianceByConfigRuleRequest &request)const;
 			void getResourceComplianceByConfigRuleAsync(const Model::GetResourceComplianceByConfigRuleRequest& request, const GetResourceComplianceByConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetResourceComplianceByConfigRuleOutcomeCallable getResourceComplianceByConfigRuleCallable(const Model::GetResourceComplianceByConfigRuleRequest& request) const;
 			GetResourceComplianceByPackOutcome getResourceComplianceByPack(const Model::GetResourceComplianceByPackRequest &request)const;
 			void getResourceComplianceByPackAsync(const Model::GetResourceComplianceByPackRequest& request, const GetResourceComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetResourceComplianceByPackOutcomeCallable getResourceComplianceByPackCallable(const Model::GetResourceComplianceByPackRequest& request) const;
+			GetResourceComplianceGroupByRegionOutcome getResourceComplianceGroupByRegion(const Model::GetResourceComplianceGroupByRegionRequest &request)const;
+			void getResourceComplianceGroupByRegionAsync(const Model::GetResourceComplianceGroupByRegionRequest& request, const GetResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceComplianceGroupByRegionOutcomeCallable getResourceComplianceGroupByRegionCallable(const Model::GetResourceComplianceGroupByRegionRequest& request) const;
+			GetResourceComplianceGroupByResourceTypeOutcome getResourceComplianceGroupByResourceType(const Model::GetResourceComplianceGroupByResourceTypeRequest &request)const;
+			void getResourceComplianceGroupByResourceTypeAsync(const Model::GetResourceComplianceGroupByResourceTypeRequest& request, const GetResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceComplianceGroupByResourceTypeOutcomeCallable getResourceComplianceGroupByResourceTypeCallable(const Model::GetResourceComplianceGroupByResourceTypeRequest& request) const;
 			GetResourceComplianceTimelineOutcome getResourceComplianceTimeline(const Model::GetResourceComplianceTimelineRequest &request)const;
 			void getResourceComplianceTimelineAsync(const Model::GetResourceComplianceTimelineRequest& request, const GetResourceComplianceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetResourceComplianceTimelineOutcomeCallable getResourceComplianceTimelineCallable(const Model::GetResourceComplianceTimelineRequest& request) const;
@@ -529,6 +574,9 @@ namespace AlibabaCloud
 			ListConfigRuleEvaluationResultsOutcome listConfigRuleEvaluationResults(const Model::ListConfigRuleEvaluationResultsRequest &request)const;
 			void listConfigRuleEvaluationResultsAsync(const Model::ListConfigRuleEvaluationResultsRequest& request, const ListConfigRuleEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListConfigRuleEvaluationResultsOutcomeCallable listConfigRuleEvaluationResultsCallable(const Model::ListConfigRuleEvaluationResultsRequest& request) const;
+			ListManagedRulesOutcome listManagedRules(const Model::ListManagedRulesRequest &request)const;
+			void listManagedRulesAsync(const Model::ListManagedRulesRequest& request, const ListManagedRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListManagedRulesOutcomeCallable listManagedRulesCallable(const Model::ListManagedRulesRequest& request) const;
 			ListResourceEvaluationResultsOutcome listResourceEvaluationResults(const Model::ListResourceEvaluationResultsRequest &request)const;
 			void listResourceEvaluationResultsAsync(const Model::ListResourceEvaluationResultsRequest& request, const ListResourceEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListResourceEvaluationResultsOutcomeCallable listResourceEvaluationResultsCallable(const Model::ListResourceEvaluationResultsRequest& request) const;

config/include/alibabacloud/config/model/CreateAggregateConfigRuleRequest.h

@@ -58,6 +58,8 @@ public:
 	void setInputParameters(const std::string &inputParameters);
 	std::string getConfigRuleName() const;
 	void setConfigRuleName(const std::string &configRuleName);
+	std::string getTagKeyLogicScope() const;
+	void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
 	std::string getMaximumExecutionFrequency() const;
 	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
 	std::string getExcludeResourceIdsScope() const;
@@ -78,6 +80,7 @@ private:
 	std::string resourceGroupIdsScope_;
 	std::string inputParameters_;
 	std::string configRuleName_;
+	std::string tagKeyLogicScope_;
 	std::string maximumExecutionFrequency_;
 	std::string excludeResourceIdsScope_;
 };

config/include/alibabacloud/config/model/CreateConfigRuleRequest.h

@@ -56,6 +56,8 @@ public:
 	void setInputParameters(const std::string &inputParameters);
 	std::string getConfigRuleName() const;
 	void setConfigRuleName(const std::string &configRuleName);
+	std::string getTagKeyLogicScope() const;
+	void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
 	std::string getMaximumExecutionFrequency() const;
 	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
 	std::string getExcludeResourceIdsScope() const;
@@ -75,6 +77,7 @@ private:
 	std::string resourceGroupIdsScope_;
 	std::string inputParameters_;
 	std::string configRuleName_;
+	std::string tagKeyLogicScope_;
 	std::string maximumExecutionFrequency_;
 	std::string excludeResourceIdsScope_;
 };

config/include/alibabacloud/config/model/GenerateAggregateConfigRulesReportRequest.h

@@ -32,11 +32,14 @@ public:
 	~GenerateAggregateConfigRulesReportRequest();
 	std::string getClientToken() const;
 	void setClientToken(const std::string &clientToken);
+	std::string getConfigRuleIds() const;
+	void setConfigRuleIds(const std::string &configRuleIds);
 	std::string getAggregatorId() const;
 	void setAggregatorId(const std::string &aggregatorId);
 
 private:
 	std::string clientToken_;
+	std::string configRuleIds_;
 	std::string aggregatorId_;
 };
 } // namespace Model

config/include/alibabacloud/config/model/GenerateAggregateConfigRulesReportResult.h

@@ -37,11 +37,13 @@ namespace AlibabaCloud
 				GenerateAggregateConfigRulesReportResult();
 				explicit GenerateAggregateConfigRulesReportResult(const std::string &payload);
 				~GenerateAggregateConfigRulesReportResult();
+				std::string getReportId()const;
 				std::string getAggregatorId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string reportId_;
 				std::string aggregatorId_;
 
 			};

config/include/alibabacloud/config/model/GenerateConfigRulesReportRequest.h

@@ -32,9 +32,12 @@ public:
 	~GenerateConfigRulesReportRequest();
 	std::string getClientToken() const;
 	void setClientToken(const std::string &clientToken);
+	std::string getConfigRuleIds() const;
+	void setConfigRuleIds(const std::string &configRuleIds);
 
 private:
 	std::string clientToken_;
+	std::string configRuleIds_;
 };
 } // namespace Model
 } // namespace Config

config/include/alibabacloud/config/model/GenerateConfigRulesReportResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				GenerateConfigRulesReportResult();
 				explicit GenerateConfigRulesReportResult(const std::string &payload);
 				~GenerateConfigRulesReportResult();
+				std::string getReportId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string reportId_;
 
 			};
 		}

config/include/alibabacloud/config/model/GetAggregateConfigRuleResult.h

@@ -94,6 +94,7 @@ namespace AlibabaCloud
 					ManagedRule managedRule;
 					std::string description;
 					std::string excludeResourceIdsScope;
+					std::string tagKeyLogicScope;
 					CreateBy createBy;
 					ConfigRuleEvaluationStatus configRuleEvaluationStatus;
 					Source source;

config/include/alibabacloud/config/model/GetAggregateConfigRulesReportRequest.h

@@ -30,10 +30,13 @@ class ALIBABACLOUD_CONFIG_EXPORT GetAggregateConfigRulesReportRequest : public R
 public:
 	GetAggregateConfigRulesReportRequest();
 	~GetAggregateConfigRulesReportRequest();
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
 	std::string getAggregatorId() const;
 	void setAggregatorId(const std::string &aggregatorId);
 
 private:
+	std::string reportId_;
 	std::string aggregatorId_;
 };
 } // namespace Model

config/include/alibabacloud/config/model/GetAggregateConfigRulesReportResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					long accountId;
 					std::string reportUrl;
+					std::string reportId;
 					std::string reportStatus;
 					std::string aggregatorId;
 					long reportCreateTimestamp;

config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionRequest.h

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

config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionResult.h

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

config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h

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

config/include/alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeResult.h

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

config/include/alibabacloud/config/model/GetConfigRuleResult.h

@@ -94,6 +94,7 @@ namespace AlibabaCloud
 					ManagedRule managedRule;
 					std::string description;
 					std::string excludeResourceIdsScope;
+					std::string tagKeyLogicScope;
 					CreateBy createBy;
 					ConfigRuleEvaluationStatus configRuleEvaluationStatus;
 					Source source;

config/include/alibabacloud/config/model/GetConfigRulesReportRequest.h

@@ -30,8 +30,11 @@ class ALIBABACLOUD_CONFIG_EXPORT GetConfigRulesReportRequest : public RpcService
 public:
 	GetConfigRulesReportRequest();
 	~GetConfigRulesReportRequest();
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
 
 private:
+	std::string reportId_;
 };
 } // namespace Model
 } // namespace Config

config/include/alibabacloud/config/model/GetConfigRulesReportResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					long accountId;
 					std::string reportUrl;
+					std::string reportId;
 					std::string reportStatus;
 					long reportCreateTimestamp;
 				};

config/include/alibabacloud/config/model/GetManagedRuleRequest.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_CONFIG_MODEL_GETMANAGEDRULEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULEREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT GetManagedRuleRequest : public RpcServiceRequest {
+public:
+	GetManagedRuleRequest();
+	~GetManagedRuleRequest();
+	std::string getIdentifier() const;
+	void setIdentifier(const std::string &identifier);
+
+private:
+	std::string identifier_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULEREQUEST_H_

config/include/alibabacloud/config/model/GetManagedRuleResult.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT GetManagedRuleResult : public ServiceResult
+			{
+			public:
+				struct ManagedRule
+				{
+					struct Scope
+					{
+						std::vector<std::string> complianceResourceTypes;
+					};
+					struct SourceDetailsItem
+					{
+						std::string eventSource;
+						std::string messageType;
+						std::string maximumExecutionFrequency;
+					};
+					std::vector<std::string> optionalInputParameterDetails;
+					std::string description;
+					std::vector<std::string> compulsoryInputParameterDetails;
+					std::string helpHint;
+					std::vector<std::string> labels;
+					std::string helpUrls;
+					std::string functionName;
+					std::string identifier;
+					Scope scope;
+					std::vector<std::string> sourceConditions;
+					std::string serviceName;
+					std::string defaultName;
+					std::string helpDoc;
+					std::string configRuleName;
+					std::string regionId;
+					std::vector<SourceDetailsItem> sourceDetails;
+					int riskLevel;
+					long createTimestamp;
+				};
+
+
+				GetManagedRuleResult();
+				explicit GetManagedRuleResult(const std::string &payload);
+				~GetManagedRuleResult();
+				ManagedRule getManagedRule()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ManagedRule managedRule_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETMANAGEDRULERESULT_H_

config/include/alibabacloud/config/model/GetResourceComplianceGroupByRegionRequest.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_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceGroupByRegionRequest : public RpcServiceRequest {
+public:
+	GetResourceComplianceGroupByRegionRequest();
+	~GetResourceComplianceGroupByRegionRequest();
+	std::string getConfigRuleIds() const;
+	void setConfigRuleIds(const std::string &configRuleIds);
+
+private:
+	std::string configRuleIds_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYREGIONREQUEST_H_

config/include/alibabacloud/config/model/GetResourceComplianceGroupByRegionResult.h

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

config/include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeRequest.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_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceGroupByResourceTypeRequest : public RpcServiceRequest {
+public:
+	GetResourceComplianceGroupByResourceTypeRequest();
+	~GetResourceComplianceGroupByResourceTypeRequest();
+	std::string getConfigRuleIds() const;
+	void setConfigRuleIds(const std::string &configRuleIds);
+
+private:
+	std::string configRuleIds_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCEGROUPBYRESOURCETYPEREQUEST_H_

config/include/alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeResult.h

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

config/include/alibabacloud/config/model/ListManagedRulesRequest.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_CONFIG_MODEL_LISTMANAGEDRULESREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT ListManagedRulesRequest : public RpcServiceRequest {
+public:
+	ListManagedRulesRequest();
+	~ListManagedRulesRequest();
+	int getRiskLevel() const;
+	void setRiskLevel(int riskLevel);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+
+private:
+	int riskLevel_;
+	int pageNumber_;
+	int pageSize_;
+	std::string keyword_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESREQUEST_H_

config/include/alibabacloud/config/model/ListManagedRulesResult.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_CONFIG_MODEL_LISTMANAGEDRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT ListManagedRulesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ManagedRule
+					{
+						std::string description;
+						std::string identifier;
+						std::string configRuleName;
+						std::vector<std::string> labels;
+						std::string useCases;
+						int riskLevel;
+						std::string helpUrls;
+						int referenceCount;
+					};
+					long totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<Data::ManagedRule> managedRuleList;
+				};
+
+
+				ListManagedRulesResult();
+				explicit ListManagedRulesResult(const std::string &payload);
+				~ListManagedRulesResult();
+				std::vector<Data> getManagedRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Data> managedRules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTMANAGEDRULESRESULT_H_

config/include/alibabacloud/config/model/UpdateAggregateConfigRuleRequest.h

@@ -56,6 +56,8 @@ public:
 	void setInputParameters(const std::string &inputParameters);
 	std::string getConfigRuleName() const;
 	void setConfigRuleName(const std::string &configRuleName);
+	std::string getTagKeyLogicScope() const;
+	void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
 	std::string getMaximumExecutionFrequency() const;
 	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
 	std::string getExcludeResourceIdsScope() const;
@@ -75,6 +77,7 @@ private:
 	std::string resourceGroupIdsScope_;
 	std::string inputParameters_;
 	std::string configRuleName_;
+	std::string tagKeyLogicScope_;
 	std::string maximumExecutionFrequency_;
 	std::string excludeResourceIdsScope_;
 };

config/include/alibabacloud/config/model/UpdateConfigRuleRequest.h

@@ -54,6 +54,8 @@ public:
 	void setInputParameters(const std::string &inputParameters);
 	std::string getConfigRuleName() const;
 	void setConfigRuleName(const std::string &configRuleName);
+	std::string getTagKeyLogicScope() const;
+	void setTagKeyLogicScope(const std::string &tagKeyLogicScope);
 	std::string getMaximumExecutionFrequency() const;
 	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
 	std::string getExcludeResourceIdsScope() const;
@@ -72,6 +74,7 @@ private:
 	std::string resourceGroupIdsScope_;
 	std::string inputParameters_;
 	std::string configRuleName_;
+	std::string tagKeyLogicScope_;
 	std::string maximumExecutionFrequency_;
 	std::string excludeResourceIdsScope_;
 };

config/src/ConfigClient.cc

@@ -1095,6 +1095,78 @@ ConfigClient::GetAggregateResourceComplianceByPackOutcomeCallable ConfigClient::
 	return task->get_future();
 }
 
+ConfigClient::GetAggregateResourceComplianceGroupByRegionOutcome ConfigClient::getAggregateResourceComplianceGroupByRegion(const GetAggregateResourceComplianceGroupByRegionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAggregateResourceComplianceGroupByRegionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAggregateResourceComplianceGroupByRegionOutcome(GetAggregateResourceComplianceGroupByRegionResult(outcome.result()));
+	else
+		return GetAggregateResourceComplianceGroupByRegionOutcome(outcome.error());
+}
+
+void ConfigClient::getAggregateResourceComplianceGroupByRegionAsync(const GetAggregateResourceComplianceGroupByRegionRequest& request, const GetAggregateResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAggregateResourceComplianceGroupByRegion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetAggregateResourceComplianceGroupByRegionOutcomeCallable ConfigClient::getAggregateResourceComplianceGroupByRegionCallable(const GetAggregateResourceComplianceGroupByRegionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAggregateResourceComplianceGroupByRegionOutcome()>>(
+			[this, request]()
+			{
+			return this->getAggregateResourceComplianceGroupByRegion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetAggregateResourceComplianceGroupByResourceTypeOutcome ConfigClient::getAggregateResourceComplianceGroupByResourceType(const GetAggregateResourceComplianceGroupByResourceTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAggregateResourceComplianceGroupByResourceTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAggregateResourceComplianceGroupByResourceTypeOutcome(GetAggregateResourceComplianceGroupByResourceTypeResult(outcome.result()));
+	else
+		return GetAggregateResourceComplianceGroupByResourceTypeOutcome(outcome.error());
+}
+
+void ConfigClient::getAggregateResourceComplianceGroupByResourceTypeAsync(const GetAggregateResourceComplianceGroupByResourceTypeRequest& request, const GetAggregateResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAggregateResourceComplianceGroupByResourceType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetAggregateResourceComplianceGroupByResourceTypeOutcomeCallable ConfigClient::getAggregateResourceComplianceGroupByResourceTypeCallable(const GetAggregateResourceComplianceGroupByResourceTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAggregateResourceComplianceGroupByResourceTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->getAggregateResourceComplianceGroupByResourceType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ConfigClient::GetAggregateResourceComplianceTimelineOutcome ConfigClient::getAggregateResourceComplianceTimeline(const GetAggregateResourceComplianceTimelineRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1563,6 +1635,42 @@ ConfigClient::GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable Conf
 	return task->get_future();
 }
 
+ConfigClient::GetManagedRuleOutcome ConfigClient::getManagedRule(const GetManagedRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetManagedRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetManagedRuleOutcome(GetManagedRuleResult(outcome.result()));
+	else
+		return GetManagedRuleOutcome(outcome.error());
+}
+
+void ConfigClient::getManagedRuleAsync(const GetManagedRuleRequest& request, const GetManagedRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getManagedRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetManagedRuleOutcomeCallable ConfigClient::getManagedRuleCallable(const GetManagedRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetManagedRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->getManagedRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ConfigClient::GetResourceComplianceByConfigRuleOutcome ConfigClient::getResourceComplianceByConfigRule(const GetResourceComplianceByConfigRuleRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1635,6 +1743,78 @@ ConfigClient::GetResourceComplianceByPackOutcomeCallable ConfigClient::getResour
 	return task->get_future();
 }
 
+ConfigClient::GetResourceComplianceGroupByRegionOutcome ConfigClient::getResourceComplianceGroupByRegion(const GetResourceComplianceGroupByRegionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceComplianceGroupByRegionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceComplianceGroupByRegionOutcome(GetResourceComplianceGroupByRegionResult(outcome.result()));
+	else
+		return GetResourceComplianceGroupByRegionOutcome(outcome.error());
+}
+
+void ConfigClient::getResourceComplianceGroupByRegionAsync(const GetResourceComplianceGroupByRegionRequest& request, const GetResourceComplianceGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceComplianceGroupByRegion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetResourceComplianceGroupByRegionOutcomeCallable ConfigClient::getResourceComplianceGroupByRegionCallable(const GetResourceComplianceGroupByRegionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceComplianceGroupByRegionOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceComplianceGroupByRegion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetResourceComplianceGroupByResourceTypeOutcome ConfigClient::getResourceComplianceGroupByResourceType(const GetResourceComplianceGroupByResourceTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceComplianceGroupByResourceTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceComplianceGroupByResourceTypeOutcome(GetResourceComplianceGroupByResourceTypeResult(outcome.result()));
+	else
+		return GetResourceComplianceGroupByResourceTypeOutcome(outcome.error());
+}
+
+void ConfigClient::getResourceComplianceGroupByResourceTypeAsync(const GetResourceComplianceGroupByResourceTypeRequest& request, const GetResourceComplianceGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceComplianceGroupByResourceType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetResourceComplianceGroupByResourceTypeOutcomeCallable ConfigClient::getResourceComplianceGroupByResourceTypeCallable(const GetResourceComplianceGroupByResourceTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceComplianceGroupByResourceTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceComplianceGroupByResourceType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ConfigClient::GetResourceComplianceTimelineOutcome ConfigClient::getResourceComplianceTimeline(const GetResourceComplianceTimelineRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2067,6 +2247,42 @@ ConfigClient::ListConfigRuleEvaluationResultsOutcomeCallable ConfigClient::listC
 	return task->get_future();
 }
 
+ConfigClient::ListManagedRulesOutcome ConfigClient::listManagedRules(const ListManagedRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListManagedRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListManagedRulesOutcome(ListManagedRulesResult(outcome.result()));
+	else
+		return ListManagedRulesOutcome(outcome.error());
+}
+
+void ConfigClient::listManagedRulesAsync(const ListManagedRulesRequest& request, const ListManagedRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listManagedRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::ListManagedRulesOutcomeCallable ConfigClient::listManagedRulesCallable(const ListManagedRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListManagedRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listManagedRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ConfigClient::ListResourceEvaluationResultsOutcome ConfigClient::listResourceEvaluationResults(const ListResourceEvaluationResultsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

config/src/model/CreateAggregateConfigRuleRequest.cc

@@ -153,6 +153,15 @@ void CreateAggregateConfigRuleRequest::setConfigRuleName(const std::string &conf
   setBodyParameter(std::string("ConfigRuleName"), configRuleName);
 }
 
+std::string CreateAggregateConfigRuleRequest::getTagKeyLogicScope() const {
+  return tagKeyLogicScope_;
+}
+
+void CreateAggregateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
+  tagKeyLogicScope_ = tagKeyLogicScope;
+  setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
+}
+
 std::string CreateAggregateConfigRuleRequest::getMaximumExecutionFrequency() const {
   return maximumExecutionFrequency_;
 }

config/src/model/CreateConfigRuleRequest.cc

@@ -144,6 +144,15 @@ void CreateConfigRuleRequest::setConfigRuleName(const std::string &configRuleNam
   setBodyParameter(std::string("ConfigRuleName"), configRuleName);
 }
 
+std::string CreateConfigRuleRequest::getTagKeyLogicScope() const {
+  return tagKeyLogicScope_;
+}
+
+void CreateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
+  tagKeyLogicScope_ = tagKeyLogicScope;
+  setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
+}
+
 std::string CreateConfigRuleRequest::getMaximumExecutionFrequency() const {
   return maximumExecutionFrequency_;
 }

config/src/model/GenerateAggregateConfigRulesReportRequest.cc

@@ -34,6 +34,15 @@ void GenerateAggregateConfigRulesReportRequest::setClientToken(const std::string
   setBodyParameter(std::string("ClientToken"), clientToken);
 }
 
+std::string GenerateAggregateConfigRulesReportRequest::getConfigRuleIds() const {
+  return configRuleIds_;
+}
+
+void GenerateAggregateConfigRulesReportRequest::setConfigRuleIds(const std::string &configRuleIds) {
+  configRuleIds_ = configRuleIds;
+  setBodyParameter(std::string("ConfigRuleIds"), configRuleIds);
+}
+
 std::string GenerateAggregateConfigRulesReportRequest::getAggregatorId() const {
   return aggregatorId_;
 }

config/src/model/GenerateAggregateConfigRulesReportResult.cc

@@ -41,9 +41,16 @@ void GenerateAggregateConfigRulesReportResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["AggregatorId"].isNull())
 		aggregatorId_ = value["AggregatorId"].asString();
+	if(!value["ReportId"].isNull())
+		reportId_ = value["ReportId"].asString();
 
 }
 
+std::string GenerateAggregateConfigRulesReportResult::getReportId()const
+{
+	return reportId_;
+}
+
 std::string GenerateAggregateConfigRulesReportResult::getAggregatorId()const
 {
 	return aggregatorId_;

config/src/model/GenerateConfigRulesReportRequest.cc

@@ -34,3 +34,12 @@ void GenerateConfigRulesReportRequest::setClientToken(const std::string &clientT
   setBodyParameter(std::string("ClientToken"), clientToken);
 }
 
+std::string GenerateConfigRulesReportRequest::getConfigRuleIds() const {
+  return configRuleIds_;
+}
+
+void GenerateConfigRulesReportRequest::setConfigRuleIds(const std::string &configRuleIds) {
+  configRuleIds_ = configRuleIds;
+  setBodyParameter(std::string("ConfigRuleIds"), configRuleIds);
+}
+

config/src/model/GenerateConfigRulesReportResult.cc

@@ -39,6 +39,13 @@ void GenerateConfigRulesReportResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["ReportId"].isNull())
+		reportId_ = value["ReportId"].asString();
 
 }
 
+std::string GenerateConfigRulesReportResult::getReportId()const
+{
+	return reportId_;
+}
+

config/src/model/GetAggregateConfigRuleResult.cc

@@ -74,6 +74,8 @@ void GetAggregateConfigRuleResult::parse(const std::string &payload)
 		configRule_.tagValueScope = configRuleNode["TagValueScope"].asString();
 	if(!configRuleNode["ConfigRuleTriggerTypes"].isNull())
 		configRule_.configRuleTriggerTypes = configRuleNode["ConfigRuleTriggerTypes"].asString();
+	if(!configRuleNode["TagKeyLogicScope"].isNull())
+		configRule_.tagKeyLogicScope = configRuleNode["TagKeyLogicScope"].asString();
 	auto sourceNode = configRuleNode["Source"];
 	if(!sourceNode["Owner"].isNull())
 		configRule_.source.owner = sourceNode["Owner"].asString();

config/src/model/GetAggregateConfigRulesReportRequest.cc

@@ -20,11 +20,20 @@ using AlibabaCloud::Config::Model::GetAggregateConfigRulesReportRequest;
 
 GetAggregateConfigRulesReportRequest::GetAggregateConfigRulesReportRequest()
     : RpcServiceRequest("config", "2020-09-07", "GetAggregateConfigRulesReport") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 GetAggregateConfigRulesReportRequest::~GetAggregateConfigRulesReportRequest() {}
 
+std::string GetAggregateConfigRulesReportRequest::getReportId() const {
+  return reportId_;
+}
+
+void GetAggregateConfigRulesReportRequest::setReportId(const std::string &reportId) {
+  reportId_ = reportId;
+  setParameter(std::string("ReportId"), reportId);
+}
+
 std::string GetAggregateConfigRulesReportRequest::getAggregatorId() const {
   return aggregatorId_;
 }

config/src/model/GetAggregateConfigRulesReportResult.cc

@@ -50,6 +50,8 @@ void GetAggregateConfigRulesReportResult::parse(const std::string &payload)
 		configRulesReport_.aggregatorId = configRulesReportNode["AggregatorId"].asString();
 	if(!configRulesReportNode["ReportCreateTimestamp"].isNull())
 		configRulesReport_.reportCreateTimestamp = std::stol(configRulesReportNode["ReportCreateTimestamp"].asString());
+	if(!configRulesReportNode["ReportId"].isNull())
+		configRulesReport_.reportId = configRulesReportNode["ReportId"].asString();
 
 }
 

config/src/model/GetAggregateResourceComplianceByConfigRuleRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Config::Model::GetAggregateResourceComplianceByConfigRuleReq
 
 GetAggregateResourceComplianceByConfigRuleRequest::GetAggregateResourceComplianceByConfigRuleRequest()
     : RpcServiceRequest("config", "2020-09-07", "GetAggregateResourceComplianceByConfigRule") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 GetAggregateResourceComplianceByConfigRuleRequest::~GetAggregateResourceComplianceByConfigRuleRequest() {}

config/src/model/GetAggregateResourceComplianceGroupByRegionRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionRequest.h>
+
+using AlibabaCloud::Config::Model::GetAggregateResourceComplianceGroupByRegionRequest;
+
+GetAggregateResourceComplianceGroupByRegionRequest::GetAggregateResourceComplianceGroupByRegionRequest()
+    : RpcServiceRequest("config", "2020-09-07", "GetAggregateResourceComplianceGroupByRegion") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAggregateResourceComplianceGroupByRegionRequest::~GetAggregateResourceComplianceGroupByRegionRequest() {}
+
+std::string GetAggregateResourceComplianceGroupByRegionRequest::getConfigRuleIds() const {
+  return configRuleIds_;
+}
+
+void GetAggregateResourceComplianceGroupByRegionRequest::setConfigRuleIds(const std::string &configRuleIds) {
+  configRuleIds_ = configRuleIds;
+  setParameter(std::string("ConfigRuleIds"), configRuleIds);
+}
+
+std::string GetAggregateResourceComplianceGroupByRegionRequest::getAggregatorId() const {
+  return aggregatorId_;
+}
+
+void GetAggregateResourceComplianceGroupByRegionRequest::setAggregatorId(const std::string &aggregatorId) {
+  aggregatorId_ = aggregatorId;
+  setParameter(std::string("AggregatorId"), aggregatorId);
+}
+

config/src/model/GetAggregateResourceComplianceGroupByRegionResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByRegionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetAggregateResourceComplianceGroupByRegionResult::GetAggregateResourceComplianceGroupByRegionResult() :
+	ServiceResult()
+{}
+
+GetAggregateResourceComplianceGroupByRegionResult::GetAggregateResourceComplianceGroupByRegionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAggregateResourceComplianceGroupByRegionResult::~GetAggregateResourceComplianceGroupByRegionResult()
+{}
+
+void GetAggregateResourceComplianceGroupByRegionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto complianceResultNode = value["ComplianceResult"];
+	auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
+	for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
+	{
+		ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
+		if(!complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].isNull())
+			complianceResultListItemObject.regionId = complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].asString();
+		auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
+		for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
+		{
+			ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
+				compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
+				compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
+			complianceResultListItemObject.compliances.push_back(compliancesObject);
+		}
+		complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
+	}
+
+}
+
+GetAggregateResourceComplianceGroupByRegionResult::ComplianceResult GetAggregateResourceComplianceGroupByRegionResult::getComplianceResult()const
+{
+	return complianceResult_;
+}
+

config/src/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeRequest.h>
+
+using AlibabaCloud::Config::Model::GetAggregateResourceComplianceGroupByResourceTypeRequest;
+
+GetAggregateResourceComplianceGroupByResourceTypeRequest::GetAggregateResourceComplianceGroupByResourceTypeRequest()
+    : RpcServiceRequest("config", "2020-09-07", "GetAggregateResourceComplianceGroupByResourceType") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAggregateResourceComplianceGroupByResourceTypeRequest::~GetAggregateResourceComplianceGroupByResourceTypeRequest() {}
+
+std::string GetAggregateResourceComplianceGroupByResourceTypeRequest::getConfigRuleIds() const {
+  return configRuleIds_;
+}
+
+void GetAggregateResourceComplianceGroupByResourceTypeRequest::setConfigRuleIds(const std::string &configRuleIds) {
+  configRuleIds_ = configRuleIds;
+  setParameter(std::string("ConfigRuleIds"), configRuleIds);
+}
+
+std::string GetAggregateResourceComplianceGroupByResourceTypeRequest::getAggregatorId() const {
+  return aggregatorId_;
+}
+
+void GetAggregateResourceComplianceGroupByResourceTypeRequest::setAggregatorId(const std::string &aggregatorId) {
+  aggregatorId_ = aggregatorId;
+  setParameter(std::string("AggregatorId"), aggregatorId);
+}
+

config/src/model/GetAggregateResourceComplianceGroupByResourceTypeResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetAggregateResourceComplianceGroupByResourceTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetAggregateResourceComplianceGroupByResourceTypeResult::GetAggregateResourceComplianceGroupByResourceTypeResult() :
+	ServiceResult()
+{}
+
+GetAggregateResourceComplianceGroupByResourceTypeResult::GetAggregateResourceComplianceGroupByResourceTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAggregateResourceComplianceGroupByResourceTypeResult::~GetAggregateResourceComplianceGroupByResourceTypeResult()
+{}
+
+void GetAggregateResourceComplianceGroupByResourceTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto complianceResultNode = value["ComplianceResult"];
+	auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
+	for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
+	{
+		ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
+		if(!complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].isNull())
+			complianceResultListItemObject.resourceType = complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].asString();
+		auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
+		for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
+		{
+			ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
+				compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
+				compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
+			complianceResultListItemObject.compliances.push_back(compliancesObject);
+		}
+		complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
+	}
+
+}
+
+GetAggregateResourceComplianceGroupByResourceTypeResult::ComplianceResult GetAggregateResourceComplianceGroupByResourceTypeResult::getComplianceResult()const
+{
+	return complianceResult_;
+}
+

config/src/model/GetConfigRuleResult.cc

@@ -74,6 +74,8 @@ void GetConfigRuleResult::parse(const std::string &payload)
 		configRule_.tagValueScope = configRuleNode["TagValueScope"].asString();
 	if(!configRuleNode["ConfigRuleTriggerTypes"].isNull())
 		configRule_.configRuleTriggerTypes = configRuleNode["ConfigRuleTriggerTypes"].asString();
+	if(!configRuleNode["TagKeyLogicScope"].isNull())
+		configRule_.tagKeyLogicScope = configRuleNode["TagKeyLogicScope"].asString();
 	auto sourceNode = configRuleNode["Source"];
 	if(!sourceNode["Owner"].isNull())
 		configRule_.source.owner = sourceNode["Owner"].asString();

config/src/model/GetConfigRulesReportRequest.cc

@@ -20,8 +20,17 @@ using AlibabaCloud::Config::Model::GetConfigRulesReportRequest;
 
 GetConfigRulesReportRequest::GetConfigRulesReportRequest()
     : RpcServiceRequest("config", "2020-09-07", "GetConfigRulesReport") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 GetConfigRulesReportRequest::~GetConfigRulesReportRequest() {}
 
+std::string GetConfigRulesReportRequest::getReportId() const {
+  return reportId_;
+}
+
+void GetConfigRulesReportRequest::setReportId(const std::string &reportId) {
+  reportId_ = reportId;
+  setParameter(std::string("ReportId"), reportId);
+}
+

config/src/model/GetConfigRulesReportResult.cc

@@ -48,6 +48,8 @@ void GetConfigRulesReportResult::parse(const std::string &payload)
 		configRulesReport_.accountId = std::stol(configRulesReportNode["AccountId"].asString());
 	if(!configRulesReportNode["ReportCreateTimestamp"].isNull())
 		configRulesReport_.reportCreateTimestamp = std::stol(configRulesReportNode["ReportCreateTimestamp"].asString());
+	if(!configRulesReportNode["ReportId"].isNull())
+		configRulesReport_.reportId = configRulesReportNode["ReportId"].asString();
 
 }
 

config/src/model/GetManagedRuleRequest.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/config/model/GetManagedRuleRequest.h>
+
+using AlibabaCloud::Config::Model::GetManagedRuleRequest;
+
+GetManagedRuleRequest::GetManagedRuleRequest()
+    : RpcServiceRequest("config", "2020-09-07", "GetManagedRule") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetManagedRuleRequest::~GetManagedRuleRequest() {}
+
+std::string GetManagedRuleRequest::getIdentifier() const {
+  return identifier_;
+}
+
+void GetManagedRuleRequest::setIdentifier(const std::string &identifier) {
+  identifier_ = identifier;
+  setParameter(std::string("Identifier"), identifier);
+}
+

config/src/model/GetManagedRuleResult.cc

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/config/model/GetManagedRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetManagedRuleResult::GetManagedRuleResult() :
+	ServiceResult()
+{}
+
+GetManagedRuleResult::GetManagedRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetManagedRuleResult::~GetManagedRuleResult()
+{}
+
+void GetManagedRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto managedRuleNode = value["ManagedRule"];
+	if(!managedRuleNode["RiskLevel"].isNull())
+		managedRule_.riskLevel = std::stoi(managedRuleNode["RiskLevel"].asString());
+	if(!managedRuleNode["HelpHint"].isNull())
+		managedRule_.helpHint = managedRuleNode["HelpHint"].asString();
+	if(!managedRuleNode["DefaultName"].isNull())
+		managedRule_.defaultName = managedRuleNode["DefaultName"].asString();
+	if(!managedRuleNode["Identifier"].isNull())
+		managedRule_.identifier = managedRuleNode["Identifier"].asString();
+	if(!managedRuleNode["RegionId"].isNull())
+		managedRule_.regionId = managedRuleNode["RegionId"].asString();
+	if(!managedRuleNode["Description"].isNull())
+		managedRule_.description = managedRuleNode["Description"].asString();
+	if(!managedRuleNode["FunctionName"].isNull())
+		managedRule_.functionName = managedRuleNode["FunctionName"].asString();
+	if(!managedRuleNode["ConfigRuleName"].isNull())
+		managedRule_.configRuleName = managedRuleNode["ConfigRuleName"].asString();
+	if(!managedRuleNode["HelpDoc"].isNull())
+		managedRule_.helpDoc = managedRuleNode["HelpDoc"].asString();
+	if(!managedRuleNode["HelpUrls"].isNull())
+		managedRule_.helpUrls = managedRuleNode["HelpUrls"].asString();
+	if(!managedRuleNode["ServiceName"].isNull())
+		managedRule_.serviceName = managedRuleNode["ServiceName"].asString();
+	if(!managedRuleNode["CreateTimestamp"].isNull())
+		managedRule_.createTimestamp = std::stol(managedRuleNode["CreateTimestamp"].asString());
+	auto allSourceDetailsNode = managedRuleNode["SourceDetails"]["SourceDetailsItem"];
+	for (auto managedRuleNodeSourceDetailsSourceDetailsItem : allSourceDetailsNode)
+	{
+		ManagedRule::SourceDetailsItem sourceDetailsItemObject;
+		if(!managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].isNull())
+			sourceDetailsItemObject.messageType = managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].asString();
+		if(!managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].isNull())
+			sourceDetailsItemObject.eventSource = managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].asString();
+		if(!managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].isNull())
+			sourceDetailsItemObject.maximumExecutionFrequency = managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].asString();
+		managedRule_.sourceDetails.push_back(sourceDetailsItemObject);
+	}
+	auto scopeNode = managedRuleNode["Scope"];
+		auto allComplianceResourceTypes = scopeNode["ComplianceResourceTypes"]["ComplianceResourceTypes"];
+		for (auto value : allComplianceResourceTypes)
+			managedRule_.scope.complianceResourceTypes.push_back(value.asString());
+		auto allLabels = managedRuleNode["Labels"]["Labels"];
+		for (auto value : allLabels)
+			managedRule_.labels.push_back(value.asString());
+		auto allSourceConditions = managedRuleNode["SourceConditions"]["SourceConditions"];
+		for (auto value : allSourceConditions)
+			managedRule_.sourceConditions.push_back(value.asString());
+		auto allOptionalInputParameterDetails = managedRuleNode["OptionalInputParameterDetails"]["OptionalInputParameterDetails"];
+		for (auto value : allOptionalInputParameterDetails)
+			managedRule_.optionalInputParameterDetails.push_back(value.asString());
+		auto allCompulsoryInputParameterDetails = managedRuleNode["CompulsoryInputParameterDetails"]["CompulsoryInputParameterDetails"];
+		for (auto value : allCompulsoryInputParameterDetails)
+			managedRule_.compulsoryInputParameterDetails.push_back(value.asString());
+
+}
+
+GetManagedRuleResult::ManagedRule GetManagedRuleResult::getManagedRule()const
+{
+	return managedRule_;
+}
+

config/src/model/GetResourceComplianceGroupByRegionRequest.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/config/model/GetResourceComplianceGroupByRegionRequest.h>
+
+using AlibabaCloud::Config::Model::GetResourceComplianceGroupByRegionRequest;
+
+GetResourceComplianceGroupByRegionRequest::GetResourceComplianceGroupByRegionRequest()
+    : RpcServiceRequest("config", "2020-09-07", "GetResourceComplianceGroupByRegion") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetResourceComplianceGroupByRegionRequest::~GetResourceComplianceGroupByRegionRequest() {}
+
+std::string GetResourceComplianceGroupByRegionRequest::getConfigRuleIds() const {
+  return configRuleIds_;
+}
+
+void GetResourceComplianceGroupByRegionRequest::setConfigRuleIds(const std::string &configRuleIds) {
+  configRuleIds_ = configRuleIds;
+  setParameter(std::string("ConfigRuleIds"), configRuleIds);
+}
+

config/src/model/GetResourceComplianceGroupByRegionResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetResourceComplianceGroupByRegionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetResourceComplianceGroupByRegionResult::GetResourceComplianceGroupByRegionResult() :
+	ServiceResult()
+{}
+
+GetResourceComplianceGroupByRegionResult::GetResourceComplianceGroupByRegionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceComplianceGroupByRegionResult::~GetResourceComplianceGroupByRegionResult()
+{}
+
+void GetResourceComplianceGroupByRegionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto complianceResultNode = value["ComplianceResult"];
+	auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
+	for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
+	{
+		ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
+		if(!complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].isNull())
+			complianceResultListItemObject.regionId = complianceResultNodeComplianceResultListComplianceResultListItem["RegionId"].asString();
+		auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
+		for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
+		{
+			ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
+				compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
+				compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
+			complianceResultListItemObject.compliances.push_back(compliancesObject);
+		}
+		complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
+	}
+
+}
+
+GetResourceComplianceGroupByRegionResult::ComplianceResult GetResourceComplianceGroupByRegionResult::getComplianceResult()const
+{
+	return complianceResult_;
+}
+

config/src/model/GetResourceComplianceGroupByResourceTypeRequest.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/config/model/GetResourceComplianceGroupByResourceTypeRequest.h>
+
+using AlibabaCloud::Config::Model::GetResourceComplianceGroupByResourceTypeRequest;
+
+GetResourceComplianceGroupByResourceTypeRequest::GetResourceComplianceGroupByResourceTypeRequest()
+    : RpcServiceRequest("config", "2020-09-07", "GetResourceComplianceGroupByResourceType") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetResourceComplianceGroupByResourceTypeRequest::~GetResourceComplianceGroupByResourceTypeRequest() {}
+
+std::string GetResourceComplianceGroupByResourceTypeRequest::getConfigRuleIds() const {
+  return configRuleIds_;
+}
+
+void GetResourceComplianceGroupByResourceTypeRequest::setConfigRuleIds(const std::string &configRuleIds) {
+  configRuleIds_ = configRuleIds;
+  setParameter(std::string("ConfigRuleIds"), configRuleIds);
+}
+

config/src/model/GetResourceComplianceGroupByResourceTypeResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetResourceComplianceGroupByResourceTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetResourceComplianceGroupByResourceTypeResult::GetResourceComplianceGroupByResourceTypeResult() :
+	ServiceResult()
+{}
+
+GetResourceComplianceGroupByResourceTypeResult::GetResourceComplianceGroupByResourceTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceComplianceGroupByResourceTypeResult::~GetResourceComplianceGroupByResourceTypeResult()
+{}
+
+void GetResourceComplianceGroupByResourceTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto complianceResultNode = value["ComplianceResult"];
+	auto allComplianceResultListNode = complianceResultNode["ComplianceResultList"]["ComplianceResultListItem"];
+	for (auto complianceResultNodeComplianceResultListComplianceResultListItem : allComplianceResultListNode)
+	{
+		ComplianceResult::ComplianceResultListItem complianceResultListItemObject;
+		if(!complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].isNull())
+			complianceResultListItemObject.resourceType = complianceResultNodeComplianceResultListComplianceResultListItem["ResourceType"].asString();
+		auto allCompliancesNode = complianceResultNodeComplianceResultListComplianceResultListItem["Compliances"]["CompliancesItem"];
+		for (auto complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem : allCompliancesNode)
+		{
+			ComplianceResult::ComplianceResultListItem::CompliancesItem compliancesObject;
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].isNull())
+				compliancesObject.complianceType = complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["ComplianceType"].asString();
+			if(!complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].isNull())
+				compliancesObject.count = std::stol(complianceResultNodeComplianceResultListComplianceResultListItemCompliancesCompliancesItem["Count"].asString());
+			complianceResultListItemObject.compliances.push_back(compliancesObject);
+		}
+		complianceResult_.complianceResultList.push_back(complianceResultListItemObject);
+	}
+
+}
+
+GetResourceComplianceGroupByResourceTypeResult::ComplianceResult GetResourceComplianceGroupByResourceTypeResult::getComplianceResult()const
+{
+	return complianceResult_;
+}
+

config/src/model/ListAggregateResourceEvaluationResultsRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Config::Model::ListAggregateResourceEvaluationResultsRequest
 
 ListAggregateResourceEvaluationResultsRequest::ListAggregateResourceEvaluationResultsRequest()
     : RpcServiceRequest("config", "2020-09-07", "ListAggregateResourceEvaluationResults") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 ListAggregateResourceEvaluationResultsRequest::~ListAggregateResourceEvaluationResultsRequest() {}

config/src/model/ListManagedRulesRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/ListManagedRulesRequest.h>
+
+using AlibabaCloud::Config::Model::ListManagedRulesRequest;
+
+ListManagedRulesRequest::ListManagedRulesRequest()
+    : RpcServiceRequest("config", "2020-09-07", "ListManagedRules") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListManagedRulesRequest::~ListManagedRulesRequest() {}
+
+int ListManagedRulesRequest::getRiskLevel() const {
+  return riskLevel_;
+}
+
+void ListManagedRulesRequest::setRiskLevel(int riskLevel) {
+  riskLevel_ = riskLevel;
+  setParameter(std::string("RiskLevel"), std::to_string(riskLevel));
+}
+
+int ListManagedRulesRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListManagedRulesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+int ListManagedRulesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListManagedRulesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListManagedRulesRequest::getKeyword() const {
+  return keyword_;
+}
+
+void ListManagedRulesRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+

config/src/model/ListManagedRulesResult.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/ListManagedRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+ListManagedRulesResult::ListManagedRulesResult() :
+	ServiceResult()
+{}
+
+ListManagedRulesResult::ListManagedRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListManagedRulesResult::~ListManagedRulesResult()
+{}
+
+void ListManagedRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allManagedRulesNode = value["ManagedRules"]["Data"];
+	for (auto valueManagedRulesData : allManagedRulesNode)
+	{
+		Data managedRulesObject;
+		if(!valueManagedRulesData["PageSize"].isNull())
+			managedRulesObject.pageSize = std::stoi(valueManagedRulesData["PageSize"].asString());
+		if(!valueManagedRulesData["PageNumber"].isNull())
+			managedRulesObject.pageNumber = std::stoi(valueManagedRulesData["PageNumber"].asString());
+		if(!valueManagedRulesData["TotalCount"].isNull())
+			managedRulesObject.totalCount = std::stol(valueManagedRulesData["TotalCount"].asString());
+		auto allManagedRuleListNode = valueManagedRulesData["ManagedRuleList"]["ManagedRule"];
+		for (auto valueManagedRulesDataManagedRuleListManagedRule : allManagedRuleListNode)
+		{
+			Data::ManagedRule managedRuleListObject;
+			if(!valueManagedRulesDataManagedRuleListManagedRule["RiskLevel"].isNull())
+				managedRuleListObject.riskLevel = std::stoi(valueManagedRulesDataManagedRuleListManagedRule["RiskLevel"].asString());
+			if(!valueManagedRulesDataManagedRuleListManagedRule["Description"].isNull())
+				managedRuleListObject.description = valueManagedRulesDataManagedRuleListManagedRule["Description"].asString();
+			if(!valueManagedRulesDataManagedRuleListManagedRule["UseCases"].isNull())
+				managedRuleListObject.useCases = valueManagedRulesDataManagedRuleListManagedRule["UseCases"].asString();
+			if(!valueManagedRulesDataManagedRuleListManagedRule["Identifier"].isNull())
+				managedRuleListObject.identifier = valueManagedRulesDataManagedRuleListManagedRule["Identifier"].asString();
+			if(!valueManagedRulesDataManagedRuleListManagedRule["ConfigRuleName"].isNull())
+				managedRuleListObject.configRuleName = valueManagedRulesDataManagedRuleListManagedRule["ConfigRuleName"].asString();
+			if(!valueManagedRulesDataManagedRuleListManagedRule["ReferenceCount"].isNull())
+				managedRuleListObject.referenceCount = std::stoi(valueManagedRulesDataManagedRuleListManagedRule["ReferenceCount"].asString());
+			if(!valueManagedRulesDataManagedRuleListManagedRule["HelpUrls"].isNull())
+				managedRuleListObject.helpUrls = valueManagedRulesDataManagedRuleListManagedRule["HelpUrls"].asString();
+			auto allLabels = value["Labels"]["Labels"];
+			for (auto value : allLabels)
+				managedRuleListObject.labels.push_back(value.asString());
+			managedRulesObject.managedRuleList.push_back(managedRuleListObject);
+		}
+		managedRules_.push_back(managedRulesObject);
+	}
+
+}
+
+std::vector<ListManagedRulesResult::Data> ListManagedRulesResult::getManagedRules()const
+{
+	return managedRules_;
+}
+

config/src/model/ListResourceEvaluationResultsRequest.cc

@@ -20,7 +20,7 @@ using AlibabaCloud::Config::Model::ListResourceEvaluationResultsRequest;
 
 ListResourceEvaluationResultsRequest::ListResourceEvaluationResultsRequest()
     : RpcServiceRequest("config", "2020-09-07", "ListResourceEvaluationResults") {
-  setMethod(HttpRequest::Method::Get);
+  setMethod(HttpRequest::Method::Post);
 }
 
 ListResourceEvaluationResultsRequest::~ListResourceEvaluationResultsRequest() {}

config/src/model/UpdateAggregateConfigRuleRequest.cc

@@ -144,6 +144,15 @@ void UpdateAggregateConfigRuleRequest::setConfigRuleName(const std::string &conf
   setBodyParameter(std::string("ConfigRuleName"), configRuleName);
 }
 
+std::string UpdateAggregateConfigRuleRequest::getTagKeyLogicScope() const {
+  return tagKeyLogicScope_;
+}
+
+void UpdateAggregateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
+  tagKeyLogicScope_ = tagKeyLogicScope;
+  setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
+}
+
 std::string UpdateAggregateConfigRuleRequest::getMaximumExecutionFrequency() const {
   return maximumExecutionFrequency_;
 }

config/src/model/UpdateConfigRuleRequest.cc

@@ -135,6 +135,15 @@ void UpdateConfigRuleRequest::setConfigRuleName(const std::string &configRuleNam
   setBodyParameter(std::string("ConfigRuleName"), configRuleName);
 }
 
+std::string UpdateConfigRuleRequest::getTagKeyLogicScope() const {
+  return tagKeyLogicScope_;
+}
+
+void UpdateConfigRuleRequest::setTagKeyLogicScope(const std::string &tagKeyLogicScope) {
+  tagKeyLogicScope_ = tagKeyLogicScope;
+  setBodyParameter(std::string("TagKeyLogicScope"), tagKeyLogicScope);
+}
+
 std::string UpdateConfigRuleRequest::getMaximumExecutionFrequency() const {
   return maximumExecutionFrequency_;
 }