Support config resource recorder deliverychannel rule.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-08-31 Version: 1.36.619
+- Support config resource recorder deliverychannel rule.
+
 2020-08-31 Version: 1.36.618
 - Supported AAA for BBB.
 - Fixed bugs for CCC.

VERSION

@@ -1 +1 @@
-1.36.618
+1.36.619

config/CMakeLists.txt

@@ -0,0 +1,174 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(config_public_header 
+	include/alibabacloud/config/ConfigClient.h
+	include/alibabacloud/config/ConfigExport.h )
+
+set(config_public_header_model 
+	include/alibabacloud/config/model/ActiveConfigRulesRequest.h
+	include/alibabacloud/config/model/ActiveConfigRulesResult.h
+	include/alibabacloud/config/model/DeleteConfigRulesRequest.h
+	include/alibabacloud/config/model/DeleteConfigRulesResult.h
+	include/alibabacloud/config/model/DescribeComplianceRequest.h
+	include/alibabacloud/config/model/DescribeComplianceResult.h
+	include/alibabacloud/config/model/DescribeComplianceSummaryRequest.h
+	include/alibabacloud/config/model/DescribeComplianceSummaryResult.h
+	include/alibabacloud/config/model/DescribeConfigRuleRequest.h
+	include/alibabacloud/config/model/DescribeConfigRuleResult.h
+	include/alibabacloud/config/model/DescribeConfigurationRecorderRequest.h
+	include/alibabacloud/config/model/DescribeConfigurationRecorderResult.h
+	include/alibabacloud/config/model/DescribeDeliveryChannelsRequest.h
+	include/alibabacloud/config/model/DescribeDeliveryChannelsResult.h
+	include/alibabacloud/config/model/DescribeDiscoveredResourceRequest.h
+	include/alibabacloud/config/model/DescribeDiscoveredResourceResult.h
+	include/alibabacloud/config/model/DescribeEvaluationResultsRequest.h
+	include/alibabacloud/config/model/DescribeEvaluationResultsResult.h
+	include/alibabacloud/config/model/GetDiscoveredResourceCountsRequest.h
+	include/alibabacloud/config/model/GetDiscoveredResourceCountsResult.h
+	include/alibabacloud/config/model/GetDiscoveredResourceSummaryRequest.h
+	include/alibabacloud/config/model/GetDiscoveredResourceSummaryResult.h
+	include/alibabacloud/config/model/GetResourceComplianceTimelineRequest.h
+	include/alibabacloud/config/model/GetResourceComplianceTimelineResult.h
+	include/alibabacloud/config/model/GetResourceConfigurationTimelineRequest.h
+	include/alibabacloud/config/model/GetResourceConfigurationTimelineResult.h
+	include/alibabacloud/config/model/GetSupportedResourceTypesRequest.h
+	include/alibabacloud/config/model/GetSupportedResourceTypesResult.h
+	include/alibabacloud/config/model/ListConfigRulesRequest.h
+	include/alibabacloud/config/model/ListConfigRulesResult.h
+	include/alibabacloud/config/model/ListDiscoveredResourcesRequest.h
+	include/alibabacloud/config/model/ListDiscoveredResourcesResult.h
+	include/alibabacloud/config/model/PutConfigRuleRequest.h
+	include/alibabacloud/config/model/PutConfigRuleResult.h
+	include/alibabacloud/config/model/PutConfigurationRecorderRequest.h
+	include/alibabacloud/config/model/PutConfigurationRecorderResult.h
+	include/alibabacloud/config/model/PutDeliveryChannelRequest.h
+	include/alibabacloud/config/model/PutDeliveryChannelResult.h
+	include/alibabacloud/config/model/PutEvaluationsRequest.h
+	include/alibabacloud/config/model/PutEvaluationsResult.h
+	include/alibabacloud/config/model/StartConfigRuleEvaluationRequest.h
+	include/alibabacloud/config/model/StartConfigRuleEvaluationResult.h
+	include/alibabacloud/config/model/StartConfigurationRecorderRequest.h
+	include/alibabacloud/config/model/StartConfigurationRecorderResult.h
+	include/alibabacloud/config/model/StopConfigRulesRequest.h
+	include/alibabacloud/config/model/StopConfigRulesResult.h )
+
+set(config_src 
+	src/ConfigClient.cc
+	src/model/ActiveConfigRulesRequest.cc
+	src/model/ActiveConfigRulesResult.cc
+	src/model/DeleteConfigRulesRequest.cc
+	src/model/DeleteConfigRulesResult.cc
+	src/model/DescribeComplianceRequest.cc
+	src/model/DescribeComplianceResult.cc
+	src/model/DescribeComplianceSummaryRequest.cc
+	src/model/DescribeComplianceSummaryResult.cc
+	src/model/DescribeConfigRuleRequest.cc
+	src/model/DescribeConfigRuleResult.cc
+	src/model/DescribeConfigurationRecorderRequest.cc
+	src/model/DescribeConfigurationRecorderResult.cc
+	src/model/DescribeDeliveryChannelsRequest.cc
+	src/model/DescribeDeliveryChannelsResult.cc
+	src/model/DescribeDiscoveredResourceRequest.cc
+	src/model/DescribeDiscoveredResourceResult.cc
+	src/model/DescribeEvaluationResultsRequest.cc
+	src/model/DescribeEvaluationResultsResult.cc
+	src/model/GetDiscoveredResourceCountsRequest.cc
+	src/model/GetDiscoveredResourceCountsResult.cc
+	src/model/GetDiscoveredResourceSummaryRequest.cc
+	src/model/GetDiscoveredResourceSummaryResult.cc
+	src/model/GetResourceComplianceTimelineRequest.cc
+	src/model/GetResourceComplianceTimelineResult.cc
+	src/model/GetResourceConfigurationTimelineRequest.cc
+	src/model/GetResourceConfigurationTimelineResult.cc
+	src/model/GetSupportedResourceTypesRequest.cc
+	src/model/GetSupportedResourceTypesResult.cc
+	src/model/ListConfigRulesRequest.cc
+	src/model/ListConfigRulesResult.cc
+	src/model/ListDiscoveredResourcesRequest.cc
+	src/model/ListDiscoveredResourcesResult.cc
+	src/model/PutConfigRuleRequest.cc
+	src/model/PutConfigRuleResult.cc
+	src/model/PutConfigurationRecorderRequest.cc
+	src/model/PutConfigurationRecorderResult.cc
+	src/model/PutDeliveryChannelRequest.cc
+	src/model/PutDeliveryChannelResult.cc
+	src/model/PutEvaluationsRequest.cc
+	src/model/PutEvaluationsResult.cc
+	src/model/StartConfigRuleEvaluationRequest.cc
+	src/model/StartConfigRuleEvaluationResult.cc
+	src/model/StartConfigurationRecorderRequest.cc
+	src/model/StartConfigurationRecorderResult.cc
+	src/model/StopConfigRulesRequest.cc
+	src/model/StopConfigRulesResult.cc )
+
+add_library(config ${LIB_TYPE}
+	${config_public_header}
+	${config_public_header_model}
+	${config_src})
+
+set_target_properties(config
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}config
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(config
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_CONFIG_LIBRARY)
+endif()
+
+target_include_directories(config
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(config
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(config
+		jsoncpp)
+	target_include_directories(config
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(config
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(config
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(config
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(config
+		jsoncpp)
+endif()
+
+install(FILES ${config_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/config)
+install(FILES ${config_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/config/model)
+install(TARGETS config
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

config/include/alibabacloud/config/ConfigClient.h

@@ -0,0 +1,230 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CONFIGCLIENT_H_
+#define ALIBABACLOUD_CONFIG_CONFIGCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ConfigExport.h"
+#include "model/ActiveConfigRulesRequest.h"
+#include "model/ActiveConfigRulesResult.h"
+#include "model/DeleteConfigRulesRequest.h"
+#include "model/DeleteConfigRulesResult.h"
+#include "model/DescribeComplianceRequest.h"
+#include "model/DescribeComplianceResult.h"
+#include "model/DescribeComplianceSummaryRequest.h"
+#include "model/DescribeComplianceSummaryResult.h"
+#include "model/DescribeConfigRuleRequest.h"
+#include "model/DescribeConfigRuleResult.h"
+#include "model/DescribeConfigurationRecorderRequest.h"
+#include "model/DescribeConfigurationRecorderResult.h"
+#include "model/DescribeDeliveryChannelsRequest.h"
+#include "model/DescribeDeliveryChannelsResult.h"
+#include "model/DescribeDiscoveredResourceRequest.h"
+#include "model/DescribeDiscoveredResourceResult.h"
+#include "model/DescribeEvaluationResultsRequest.h"
+#include "model/DescribeEvaluationResultsResult.h"
+#include "model/GetDiscoveredResourceCountsRequest.h"
+#include "model/GetDiscoveredResourceCountsResult.h"
+#include "model/GetDiscoveredResourceSummaryRequest.h"
+#include "model/GetDiscoveredResourceSummaryResult.h"
+#include "model/GetResourceComplianceTimelineRequest.h"
+#include "model/GetResourceComplianceTimelineResult.h"
+#include "model/GetResourceConfigurationTimelineRequest.h"
+#include "model/GetResourceConfigurationTimelineResult.h"
+#include "model/GetSupportedResourceTypesRequest.h"
+#include "model/GetSupportedResourceTypesResult.h"
+#include "model/ListConfigRulesRequest.h"
+#include "model/ListConfigRulesResult.h"
+#include "model/ListDiscoveredResourcesRequest.h"
+#include "model/ListDiscoveredResourcesResult.h"
+#include "model/PutConfigRuleRequest.h"
+#include "model/PutConfigRuleResult.h"
+#include "model/PutConfigurationRecorderRequest.h"
+#include "model/PutConfigurationRecorderResult.h"
+#include "model/PutDeliveryChannelRequest.h"
+#include "model/PutDeliveryChannelResult.h"
+#include "model/PutEvaluationsRequest.h"
+#include "model/PutEvaluationsResult.h"
+#include "model/StartConfigRuleEvaluationRequest.h"
+#include "model/StartConfigRuleEvaluationResult.h"
+#include "model/StartConfigurationRecorderRequest.h"
+#include "model/StartConfigurationRecorderResult.h"
+#include "model/StopConfigRulesRequest.h"
+#include "model/StopConfigRulesResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		class ALIBABACLOUD_CONFIG_EXPORT ConfigClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::ActiveConfigRulesResult> ActiveConfigRulesOutcome;
+			typedef std::future<ActiveConfigRulesOutcome> ActiveConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ActiveConfigRulesRequest&, const ActiveConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActiveConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteConfigRulesResult> DeleteConfigRulesOutcome;
+			typedef std::future<DeleteConfigRulesOutcome> DeleteConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeleteConfigRulesRequest&, const DeleteConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeComplianceResult> DescribeComplianceOutcome;
+			typedef std::future<DescribeComplianceOutcome> DescribeComplianceOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeComplianceRequest&, const DescribeComplianceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeComplianceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeComplianceSummaryResult> DescribeComplianceSummaryOutcome;
+			typedef std::future<DescribeComplianceSummaryOutcome> DescribeComplianceSummaryOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeComplianceSummaryRequest&, const DescribeComplianceSummaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeComplianceSummaryAsyncHandler;
+			typedef Outcome<Error, Model::DescribeConfigRuleResult> DescribeConfigRuleOutcome;
+			typedef std::future<DescribeConfigRuleOutcome> DescribeConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeConfigRuleRequest&, const DescribeConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeConfigurationRecorderResult> DescribeConfigurationRecorderOutcome;
+			typedef std::future<DescribeConfigurationRecorderOutcome> DescribeConfigurationRecorderOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeConfigurationRecorderRequest&, const DescribeConfigurationRecorderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeConfigurationRecorderAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDeliveryChannelsResult> DescribeDeliveryChannelsOutcome;
+			typedef std::future<DescribeDeliveryChannelsOutcome> DescribeDeliveryChannelsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeDeliveryChannelsRequest&, const DescribeDeliveryChannelsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDeliveryChannelsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDiscoveredResourceResult> DescribeDiscoveredResourceOutcome;
+			typedef std::future<DescribeDiscoveredResourceOutcome> DescribeDiscoveredResourceOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeDiscoveredResourceRequest&, const DescribeDiscoveredResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDiscoveredResourceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeEvaluationResultsResult> DescribeEvaluationResultsOutcome;
+			typedef std::future<DescribeEvaluationResultsOutcome> DescribeEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DescribeEvaluationResultsRequest&, const DescribeEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::GetDiscoveredResourceCountsResult> GetDiscoveredResourceCountsOutcome;
+			typedef std::future<GetDiscoveredResourceCountsOutcome> GetDiscoveredResourceCountsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetDiscoveredResourceCountsRequest&, const GetDiscoveredResourceCountsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiscoveredResourceCountsAsyncHandler;
+			typedef Outcome<Error, Model::GetDiscoveredResourceSummaryResult> GetDiscoveredResourceSummaryOutcome;
+			typedef std::future<GetDiscoveredResourceSummaryOutcome> GetDiscoveredResourceSummaryOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetDiscoveredResourceSummaryRequest&, const GetDiscoveredResourceSummaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiscoveredResourceSummaryAsyncHandler;
+			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;
+			typedef Outcome<Error, Model::GetResourceConfigurationTimelineResult> GetResourceConfigurationTimelineOutcome;
+			typedef std::future<GetResourceConfigurationTimelineOutcome> GetResourceConfigurationTimelineOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetResourceConfigurationTimelineRequest&, const GetResourceConfigurationTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceConfigurationTimelineAsyncHandler;
+			typedef Outcome<Error, Model::GetSupportedResourceTypesResult> GetSupportedResourceTypesOutcome;
+			typedef std::future<GetSupportedResourceTypesOutcome> GetSupportedResourceTypesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetSupportedResourceTypesRequest&, const GetSupportedResourceTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSupportedResourceTypesAsyncHandler;
+			typedef Outcome<Error, Model::ListConfigRulesResult> ListConfigRulesOutcome;
+			typedef std::future<ListConfigRulesOutcome> ListConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListConfigRulesRequest&, const ListConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListDiscoveredResourcesResult> ListDiscoveredResourcesOutcome;
+			typedef std::future<ListDiscoveredResourcesOutcome> ListDiscoveredResourcesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListDiscoveredResourcesRequest&, const ListDiscoveredResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDiscoveredResourcesAsyncHandler;
+			typedef Outcome<Error, Model::PutConfigRuleResult> PutConfigRuleOutcome;
+			typedef std::future<PutConfigRuleOutcome> PutConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::PutConfigRuleRequest&, const PutConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::PutConfigurationRecorderResult> PutConfigurationRecorderOutcome;
+			typedef std::future<PutConfigurationRecorderOutcome> PutConfigurationRecorderOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::PutConfigurationRecorderRequest&, const PutConfigurationRecorderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutConfigurationRecorderAsyncHandler;
+			typedef Outcome<Error, Model::PutDeliveryChannelResult> PutDeliveryChannelOutcome;
+			typedef std::future<PutDeliveryChannelOutcome> PutDeliveryChannelOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::PutDeliveryChannelRequest&, const PutDeliveryChannelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutDeliveryChannelAsyncHandler;
+			typedef Outcome<Error, Model::PutEvaluationsResult> PutEvaluationsOutcome;
+			typedef std::future<PutEvaluationsOutcome> PutEvaluationsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::PutEvaluationsRequest&, const PutEvaluationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutEvaluationsAsyncHandler;
+			typedef Outcome<Error, Model::StartConfigRuleEvaluationResult> StartConfigRuleEvaluationOutcome;
+			typedef std::future<StartConfigRuleEvaluationOutcome> StartConfigRuleEvaluationOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::StartConfigRuleEvaluationRequest&, const StartConfigRuleEvaluationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartConfigRuleEvaluationAsyncHandler;
+			typedef Outcome<Error, Model::StartConfigurationRecorderResult> StartConfigurationRecorderOutcome;
+			typedef std::future<StartConfigurationRecorderOutcome> StartConfigurationRecorderOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::StartConfigurationRecorderRequest&, const StartConfigurationRecorderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartConfigurationRecorderAsyncHandler;
+			typedef Outcome<Error, Model::StopConfigRulesResult> StopConfigRulesOutcome;
+			typedef std::future<StopConfigRulesOutcome> StopConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::StopConfigRulesRequest&, const StopConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopConfigRulesAsyncHandler;
+
+			ConfigClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ConfigClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ConfigClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ConfigClient();
+			ActiveConfigRulesOutcome activeConfigRules(const Model::ActiveConfigRulesRequest &request)const;
+			void activeConfigRulesAsync(const Model::ActiveConfigRulesRequest& request, const ActiveConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ActiveConfigRulesOutcomeCallable activeConfigRulesCallable(const Model::ActiveConfigRulesRequest& request) const;
+			DeleteConfigRulesOutcome deleteConfigRules(const Model::DeleteConfigRulesRequest &request)const;
+			void deleteConfigRulesAsync(const Model::DeleteConfigRulesRequest& request, const DeleteConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteConfigRulesOutcomeCallable deleteConfigRulesCallable(const Model::DeleteConfigRulesRequest& request) const;
+			DescribeComplianceOutcome describeCompliance(const Model::DescribeComplianceRequest &request)const;
+			void describeComplianceAsync(const Model::DescribeComplianceRequest& request, const DescribeComplianceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeComplianceOutcomeCallable describeComplianceCallable(const Model::DescribeComplianceRequest& request) const;
+			DescribeComplianceSummaryOutcome describeComplianceSummary(const Model::DescribeComplianceSummaryRequest &request)const;
+			void describeComplianceSummaryAsync(const Model::DescribeComplianceSummaryRequest& request, const DescribeComplianceSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeComplianceSummaryOutcomeCallable describeComplianceSummaryCallable(const Model::DescribeComplianceSummaryRequest& request) const;
+			DescribeConfigRuleOutcome describeConfigRule(const Model::DescribeConfigRuleRequest &request)const;
+			void describeConfigRuleAsync(const Model::DescribeConfigRuleRequest& request, const DescribeConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeConfigRuleOutcomeCallable describeConfigRuleCallable(const Model::DescribeConfigRuleRequest& request) const;
+			DescribeConfigurationRecorderOutcome describeConfigurationRecorder(const Model::DescribeConfigurationRecorderRequest &request)const;
+			void describeConfigurationRecorderAsync(const Model::DescribeConfigurationRecorderRequest& request, const DescribeConfigurationRecorderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeConfigurationRecorderOutcomeCallable describeConfigurationRecorderCallable(const Model::DescribeConfigurationRecorderRequest& request) const;
+			DescribeDeliveryChannelsOutcome describeDeliveryChannels(const Model::DescribeDeliveryChannelsRequest &request)const;
+			void describeDeliveryChannelsAsync(const Model::DescribeDeliveryChannelsRequest& request, const DescribeDeliveryChannelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDeliveryChannelsOutcomeCallable describeDeliveryChannelsCallable(const Model::DescribeDeliveryChannelsRequest& request) const;
+			DescribeDiscoveredResourceOutcome describeDiscoveredResource(const Model::DescribeDiscoveredResourceRequest &request)const;
+			void describeDiscoveredResourceAsync(const Model::DescribeDiscoveredResourceRequest& request, const DescribeDiscoveredResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDiscoveredResourceOutcomeCallable describeDiscoveredResourceCallable(const Model::DescribeDiscoveredResourceRequest& request) const;
+			DescribeEvaluationResultsOutcome describeEvaluationResults(const Model::DescribeEvaluationResultsRequest &request)const;
+			void describeEvaluationResultsAsync(const Model::DescribeEvaluationResultsRequest& request, const DescribeEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeEvaluationResultsOutcomeCallable describeEvaluationResultsCallable(const Model::DescribeEvaluationResultsRequest& request) const;
+			GetDiscoveredResourceCountsOutcome getDiscoveredResourceCounts(const Model::GetDiscoveredResourceCountsRequest &request)const;
+			void getDiscoveredResourceCountsAsync(const Model::GetDiscoveredResourceCountsRequest& request, const GetDiscoveredResourceCountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDiscoveredResourceCountsOutcomeCallable getDiscoveredResourceCountsCallable(const Model::GetDiscoveredResourceCountsRequest& request) const;
+			GetDiscoveredResourceSummaryOutcome getDiscoveredResourceSummary(const Model::GetDiscoveredResourceSummaryRequest &request)const;
+			void getDiscoveredResourceSummaryAsync(const Model::GetDiscoveredResourceSummaryRequest& request, const GetDiscoveredResourceSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDiscoveredResourceSummaryOutcomeCallable getDiscoveredResourceSummaryCallable(const Model::GetDiscoveredResourceSummaryRequest& 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;
+			GetResourceConfigurationTimelineOutcome getResourceConfigurationTimeline(const Model::GetResourceConfigurationTimelineRequest &request)const;
+			void getResourceConfigurationTimelineAsync(const Model::GetResourceConfigurationTimelineRequest& request, const GetResourceConfigurationTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceConfigurationTimelineOutcomeCallable getResourceConfigurationTimelineCallable(const Model::GetResourceConfigurationTimelineRequest& request) const;
+			GetSupportedResourceTypesOutcome getSupportedResourceTypes(const Model::GetSupportedResourceTypesRequest &request)const;
+			void getSupportedResourceTypesAsync(const Model::GetSupportedResourceTypesRequest& request, const GetSupportedResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSupportedResourceTypesOutcomeCallable getSupportedResourceTypesCallable(const Model::GetSupportedResourceTypesRequest& request) const;
+			ListConfigRulesOutcome listConfigRules(const Model::ListConfigRulesRequest &request)const;
+			void listConfigRulesAsync(const Model::ListConfigRulesRequest& request, const ListConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListConfigRulesOutcomeCallable listConfigRulesCallable(const Model::ListConfigRulesRequest& request) const;
+			ListDiscoveredResourcesOutcome listDiscoveredResources(const Model::ListDiscoveredResourcesRequest &request)const;
+			void listDiscoveredResourcesAsync(const Model::ListDiscoveredResourcesRequest& request, const ListDiscoveredResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListDiscoveredResourcesOutcomeCallable listDiscoveredResourcesCallable(const Model::ListDiscoveredResourcesRequest& request) const;
+			PutConfigRuleOutcome putConfigRule(const Model::PutConfigRuleRequest &request)const;
+			void putConfigRuleAsync(const Model::PutConfigRuleRequest& request, const PutConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PutConfigRuleOutcomeCallable putConfigRuleCallable(const Model::PutConfigRuleRequest& request) const;
+			PutConfigurationRecorderOutcome putConfigurationRecorder(const Model::PutConfigurationRecorderRequest &request)const;
+			void putConfigurationRecorderAsync(const Model::PutConfigurationRecorderRequest& request, const PutConfigurationRecorderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PutConfigurationRecorderOutcomeCallable putConfigurationRecorderCallable(const Model::PutConfigurationRecorderRequest& request) const;
+			PutDeliveryChannelOutcome putDeliveryChannel(const Model::PutDeliveryChannelRequest &request)const;
+			void putDeliveryChannelAsync(const Model::PutDeliveryChannelRequest& request, const PutDeliveryChannelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PutDeliveryChannelOutcomeCallable putDeliveryChannelCallable(const Model::PutDeliveryChannelRequest& request) const;
+			PutEvaluationsOutcome putEvaluations(const Model::PutEvaluationsRequest &request)const;
+			void putEvaluationsAsync(const Model::PutEvaluationsRequest& request, const PutEvaluationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PutEvaluationsOutcomeCallable putEvaluationsCallable(const Model::PutEvaluationsRequest& request) const;
+			StartConfigRuleEvaluationOutcome startConfigRuleEvaluation(const Model::StartConfigRuleEvaluationRequest &request)const;
+			void startConfigRuleEvaluationAsync(const Model::StartConfigRuleEvaluationRequest& request, const StartConfigRuleEvaluationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartConfigRuleEvaluationOutcomeCallable startConfigRuleEvaluationCallable(const Model::StartConfigRuleEvaluationRequest& request) const;
+			StartConfigurationRecorderOutcome startConfigurationRecorder(const Model::StartConfigurationRecorderRequest &request)const;
+			void startConfigurationRecorderAsync(const Model::StartConfigurationRecorderRequest& request, const StartConfigurationRecorderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartConfigurationRecorderOutcomeCallable startConfigurationRecorderCallable(const Model::StartConfigurationRecorderRequest& request) const;
+			StopConfigRulesOutcome stopConfigRules(const Model::StopConfigRulesRequest &request)const;
+			void stopConfigRulesAsync(const Model::StopConfigRulesRequest& request, const StopConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopConfigRulesOutcomeCallable stopConfigRulesCallable(const Model::StopConfigRulesRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_CONFIG_CONFIGCLIENT_H_

config/include/alibabacloud/config/ConfigExport.h

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

config/include/alibabacloud/config/model/ActiveConfigRulesRequest.h

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

config/include/alibabacloud/config/model/ActiveConfigRulesResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_ACTIVECONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_ACTIVECONFIGRULESRESULT_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 ActiveConfigRulesResult : public ServiceResult
+			{
+			public:
+				struct OperateRuleResult
+				{
+					struct OperateRuleItem
+					{
+						std::string configRuleId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateRuleItem> operateRuleItemList;
+				};
+
+
+				ActiveConfigRulesResult();
+				explicit ActiveConfigRulesResult(const std::string &payload);
+				~ActiveConfigRulesResult();
+				OperateRuleResult getOperateRuleResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OperateRuleResult operateRuleResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_ACTIVECONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/DeleteConfigRulesRequest.h

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

config/include/alibabacloud/config/model/DeleteConfigRulesResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DELETECONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DELETECONFIGRULESRESULT_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 DeleteConfigRulesResult : public ServiceResult
+			{
+			public:
+				struct OperateRuleResult
+				{
+					struct OperateRuleItem
+					{
+						std::string configRuleId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateRuleItem> operateRuleItemList;
+				};
+
+
+				DeleteConfigRulesResult();
+				explicit DeleteConfigRulesResult(const std::string &payload);
+				~DeleteConfigRulesResult();
+				OperateRuleResult getOperateRuleResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OperateRuleResult operateRuleResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DELETECONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/DescribeComplianceRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT DescribeComplianceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeComplianceRequest();
+				~DescribeComplianceRequest();
+
+				std::string getConfigRuleId()const;
+				void setConfigRuleId(const std::string& configRuleId);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getComplianceType()const;
+				void setComplianceType(const std::string& complianceType);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				std::string configRuleId_;
+				std::string resourceId_;
+				bool multiAccount_;
+				std::string resourceType_;
+				std::string complianceType_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCEREQUEST_H_

config/include/alibabacloud/config/model/DescribeComplianceResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DESCRIBECOMPLIANCERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCERESULT_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 DescribeComplianceResult : public ServiceResult
+			{
+			public:
+				struct ComplianceResult
+				{
+					struct CompliancesItem
+					{
+						std::string complianceType;
+						int count;
+					};
+					long totalCount;
+					std::vector<CompliancesItem> compliances;
+				};
+
+
+				DescribeComplianceResult();
+				explicit DescribeComplianceResult(const std::string &payload);
+				~DescribeComplianceResult();
+				ComplianceResult getComplianceResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ComplianceResult complianceResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCERESULT_H_

config/include/alibabacloud/config/model/DescribeComplianceSummaryRequest.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_DESCRIBECOMPLIANCESUMMARYREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCESUMMARYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT DescribeComplianceSummaryRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeComplianceSummaryRequest();
+				~DescribeComplianceSummaryRequest();
+
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				bool multiAccount_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCESUMMARYREQUEST_H_

config/include/alibabacloud/config/model/DescribeComplianceSummaryResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DESCRIBECOMPLIANCESUMMARYRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCESUMMARYRESULT_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 DescribeComplianceSummaryResult : public ServiceResult
+			{
+			public:
+				struct ComplianceSummary
+				{
+					struct ComplianceSummaryByConfigRule
+					{
+						long totalCount;
+						int compliantCount;
+						int nonCompliantCount;
+						long complianceSummaryTimestamp;
+					};
+					struct ComplianceSummaryByResource
+					{
+						long totalCount;
+						int compliantCount;
+						int nonCompliantCount;
+						long complianceSummaryTimestamp;
+					};
+					ComplianceSummaryByResource complianceSummaryByResource;
+					ComplianceSummaryByConfigRule complianceSummaryByConfigRule;
+				};
+
+
+				DescribeComplianceSummaryResult();
+				explicit DescribeComplianceSummaryResult(const std::string &payload);
+				~DescribeComplianceSummaryResult();
+				ComplianceSummary getComplianceSummary()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ComplianceSummary complianceSummary_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBECOMPLIANCESUMMARYRESULT_H_

config/include/alibabacloud/config/model/DescribeConfigRuleRequest.h

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

config/include/alibabacloud/config/model/DescribeConfigRuleResult.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DESCRIBECONFIGRULERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBECONFIGRULERESULT_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 DescribeConfigRuleResult : public ServiceResult
+			{
+			public:
+				struct ConfigRule
+				{
+					struct CreateBy
+					{
+						std::string creatorId;
+						std::string configRuleSceneName;
+						std::string configRuleSceneId;
+						std::string creatorType;
+						std::string creatorName;
+					};
+					struct ConfigRuleEvaluationStatus
+					{
+						std::string lastErrorMessage;
+						long lastFailedInvocationTimestamp;
+						long firstActivatedTimestamp;
+						long lastSuccessfulEvaluationTimestamp;
+						bool firstEvaluationStarted;
+						long lastFailedEvaluationTimestamp;
+						std::string lastErrorCode;
+						long lastSuccessfulInvocationTimestamp;
+					};
+					struct ManagedRule
+					{
+						struct SourceDetailsItem
+						{
+							std::string eventSource;
+							std::string maximumExecutionFrequency;
+							std::string messageType;
+						};
+						std::string managedRuleName;
+						std::string optionalInputParameterDetails;
+						std::string description;
+						std::string identifier;
+						std::string compulsoryInputParameterDetails;
+						std::vector<std::string> labels;
+						std::vector<SourceDetailsItem> sourceDetails;
+						std::string helpUrl;
+					};
+					struct Source
+					{
+						struct SourceConditionsItem
+						{
+							std::string desiredValue;
+							bool required;
+							std::string _operator;
+							std::string selectPath;
+							std::string name;
+							std::string tips;
+						};
+						struct SourceDetailsItem2
+						{
+							std::string eventSource;
+							std::string maximumExecutionFrequency;
+							std::string messageType;
+						};
+						std::string owner;
+						std::string identifier;
+						std::vector<SourceConditionsItem> sourceConditions;
+						std::vector<SourceDetailsItem2> sourceDetails1;
+					};
+					struct Scope
+					{
+						std::string complianceResourceId;
+						std::vector<std::string> complianceResourceTypes;
+					};
+					ManagedRule managedRule;
+					std::string description;
+					CreateBy createBy;
+					ConfigRuleEvaluationStatus configRuleEvaluationStatus;
+					Source source;
+					std::string configRuleState;
+					std::string configRuleId;
+					Scope scope;
+					std::string configRuleArn;
+					long modifiedTimestamp;
+					std::string configRuleName;
+					long createTimestamp;
+					int riskLevel;
+					std::string inputParameters;
+				};
+
+
+				DescribeConfigRuleResult();
+				explicit DescribeConfigRuleResult(const std::string &payload);
+				~DescribeConfigRuleResult();
+				ConfigRule getConfigRule()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ConfigRule configRule_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBECONFIGRULERESULT_H_

config/include/alibabacloud/config/model/DescribeConfigurationRecorderRequest.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_DESCRIBECONFIGURATIONRECORDERREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBECONFIGURATIONRECORDERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT DescribeConfigurationRecorderRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeConfigurationRecorderRequest();
+				~DescribeConfigurationRecorderRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBECONFIGURATIONRECORDERREQUEST_H_

config/include/alibabacloud/config/model/DescribeConfigurationRecorderResult.h

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

config/include/alibabacloud/config/model/DescribeDeliveryChannelsRequest.h

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

config/include/alibabacloud/config/model/DescribeDeliveryChannelsResult.h

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

config/include/alibabacloud/config/model/DescribeDiscoveredResourceRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_DESCRIBEDISCOVEREDRESOURCEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBEDISCOVEREDRESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT DescribeDiscoveredResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDiscoveredResourceRequest();
+				~DescribeDiscoveredResourceRequest();
+
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getRegion()const;
+				void setRegion(const std::string& region);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				std::string resourceId_;
+				bool multiAccount_;
+				std::string resourceType_;
+				std::string region_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBEDISCOVEREDRESOURCEREQUEST_H_

config/include/alibabacloud/config/model/DescribeDiscoveredResourceResult.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_DESCRIBEDISCOVEREDRESOURCERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBEDISCOVEREDRESOURCERESULT_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 DescribeDiscoveredResourceResult : public ServiceResult
+			{
+			public:
+				struct DiscoveredResourceDetail
+				{
+					long accountId;
+					long resourceCreationTime;
+					std::string configuration;
+					std::string resourceId;
+					std::string resourceName;
+					std::string region;
+					std::string availabilityZone;
+					std::string resourceStatus;
+					std::string resourceType;
+					int resourceDeleted;
+					std::string tags;
+				};
+
+
+				DescribeDiscoveredResourceResult();
+				explicit DescribeDiscoveredResourceResult(const std::string &payload);
+				~DescribeDiscoveredResourceResult();
+				DiscoveredResourceDetail getDiscoveredResourceDetail()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DiscoveredResourceDetail discoveredResourceDetail_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBEDISCOVEREDRESOURCERESULT_H_

config/include/alibabacloud/config/model/DescribeEvaluationResultsRequest.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_DESCRIBEEVALUATIONRESULTSREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBEEVALUATIONRESULTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT DescribeEvaluationResultsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeEvaluationResultsRequest();
+				~DescribeEvaluationResultsRequest();
+
+				std::string getConfigRuleId()const;
+				void setConfigRuleId(const std::string& configRuleId);
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getComplianceType()const;
+				void setComplianceType(const std::string& complianceType);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				std::string configRuleId_;
+				bool multiAccount_;
+				int pageNumber_;
+				int pageSize_;
+				std::string complianceType_;
+				std::string resourceId_;
+				std::string resourceType_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBEEVALUATIONRESULTSREQUEST_H_

config/include/alibabacloud/config/model/DescribeEvaluationResultsResult.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_DESCRIBEEVALUATIONRESULTSRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DESCRIBEEVALUATIONRESULTSRESULT_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 DescribeEvaluationResultsResult : public ServiceResult
+			{
+			public:
+				struct EvaluationResults
+				{
+					struct EvaluationResult
+					{
+						struct EvaluationResultIdentifier
+						{
+							struct EvaluationResultQualifier
+							{
+								std::string configRuleId;
+								std::string configRuleArn;
+								std::string resourceId;
+								std::string configRuleName;
+								std::string resourceType;
+								std::string regionId;
+							};
+							EvaluationResultQualifier evaluationResultQualifier;
+							long orderingTimestamp;
+						};
+						long configRuleInvokedTimestamp;
+						std::string complianceType;
+						long resultRecordedTimestamp;
+						std::string invokingEventMessageType;
+						EvaluationResultIdentifier evaluationResultIdentifier;
+						int riskLevel;
+						std::string annotation;
+					};
+					std::vector<EvaluationResult> evaluationResultList;
+					long totalCount;
+					int pageSize;
+					int pageNumber;
+				};
+
+
+				DescribeEvaluationResultsResult();
+				explicit DescribeEvaluationResultsResult(const std::string &payload);
+				~DescribeEvaluationResultsResult();
+				EvaluationResults getEvaluationResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				EvaluationResults evaluationResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DESCRIBEEVALUATIONRESULTSRESULT_H_

config/include/alibabacloud/config/model/GetDiscoveredResourceCountsRequest.h

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

config/include/alibabacloud/config/model/GetDiscoveredResourceCountsResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_GETDISCOVEREDRESOURCECOUNTSRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCECOUNTSRESULT_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 GetDiscoveredResourceCountsResult : public ServiceResult
+			{
+			public:
+				struct GroupedResourceCounts
+				{
+					struct GroupedResourceCount
+					{
+						std::string groupName;
+						long resourceCount;
+					};
+					std::vector<GroupedResourceCount> groupedResourceCountList;
+					std::string groupByKey;
+				};
+
+
+				GetDiscoveredResourceCountsResult();
+				explicit GetDiscoveredResourceCountsResult(const std::string &payload);
+				~GetDiscoveredResourceCountsResult();
+				GroupedResourceCounts getGroupedResourceCounts()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				GroupedResourceCounts groupedResourceCounts_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCECOUNTSRESULT_H_

config/include/alibabacloud/config/model/GetDiscoveredResourceSummaryRequest.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_GETDISCOVEREDRESOURCESUMMARYREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCESUMMARYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT GetDiscoveredResourceSummaryRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDiscoveredResourceSummaryRequest();
+				~GetDiscoveredResourceSummaryRequest();
+
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				bool multiAccount_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCESUMMARYREQUEST_H_

config/include/alibabacloud/config/model/GetDiscoveredResourceSummaryResult.h

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

config/include/alibabacloud/config/model/GetResourceComplianceTimelineRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCETIMELINEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCETIMELINEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT GetResourceComplianceTimelineRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetResourceComplianceTimelineRequest();
+				~GetResourceComplianceTimelineRequest();
+
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getLimit()const;
+				void setLimit(int limit);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getRegion()const;
+				void setRegion(const std::string& region);
+				std::string getMemberId()const;
+				void setMemberId(const std::string& memberId);
+
+            private:
+				bool multiAccount_;
+				long startTime_;
+				std::string nextToken_;
+				int limit_;
+				std::string resourceId_;
+				long endTime_;
+				std::string resourceType_;
+				std::string region_;
+				std::string memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCETIMELINEREQUEST_H_

config/include/alibabacloud/config/model/GetResourceComplianceTimelineResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCETIMELINERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCETIMELINERESULT_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 GetResourceComplianceTimelineResult : public ServiceResult
+			{
+			public:
+				struct ResourceComplianceTimeline
+				{
+					struct ComplianceListItem
+					{
+						std::string accountId;
+						long captureTime;
+						std::string configurationDiff;
+						std::string configuration;
+						std::string resourceId;
+						std::string resourceName;
+						std::string availabilityZone;
+						std::string region;
+						std::string resourceStatus;
+						std::string resourceType;
+						long resourceCreateTime;
+						std::string tags;
+					};
+					long totalCount;
+					std::vector<ComplianceListItem> complianceList;
+					std::string nextToken;
+					int limit;
+				};
+
+
+				GetResourceComplianceTimelineResult();
+				explicit GetResourceComplianceTimelineResult(const std::string &payload);
+				~GetResourceComplianceTimelineResult();
+				ResourceComplianceTimeline getResourceComplianceTimeline()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResourceComplianceTimeline resourceComplianceTimeline_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECOMPLIANCETIMELINERESULT_H_

config/include/alibabacloud/config/model/GetResourceConfigurationTimelineRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECONFIGURATIONTIMELINEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECONFIGURATIONTIMELINEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT GetResourceConfigurationTimelineRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetResourceConfigurationTimelineRequest();
+				~GetResourceConfigurationTimelineRequest();
+
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				int getLimit()const;
+				void setLimit(int limit);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getRegion()const;
+				void setRegion(const std::string& region);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				bool multiAccount_;
+				long startTime_;
+				std::string nextToken_;
+				int limit_;
+				std::string resourceId_;
+				long endTime_;
+				std::string resourceType_;
+				std::string region_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECONFIGURATIONTIMELINEREQUEST_H_

config/include/alibabacloud/config/model/GetResourceConfigurationTimelineResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECONFIGURATIONTIMELINERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECONFIGURATIONTIMELINERESULT_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 GetResourceConfigurationTimelineResult : public ServiceResult
+			{
+			public:
+				struct ResourceConfigurationTimeline
+				{
+					struct ConfigurationListItem
+					{
+						long accountId;
+						std::string captureTime;
+						std::string configurationDiff;
+						std::string resourceId;
+						std::string resourceName;
+						std::string relationship;
+						std::string availabilityZone;
+						std::string region;
+						std::string resourceType;
+						std::string resourceCreateTime;
+						std::string relationshipDiff;
+						std::string tags;
+					};
+					long totalCount;
+					std::string nextToken;
+					std::vector<ConfigurationListItem> configurationList;
+					int limit;
+				};
+
+
+				GetResourceConfigurationTimelineResult();
+				explicit GetResourceConfigurationTimelineResult(const std::string &payload);
+				~GetResourceConfigurationTimelineResult();
+				ResourceConfigurationTimeline getResourceConfigurationTimeline()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResourceConfigurationTimeline resourceConfigurationTimeline_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETRESOURCECONFIGURATIONTIMELINERESULT_H_

config/include/alibabacloud/config/model/GetSupportedResourceTypesRequest.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_GETSUPPORTEDRESOURCETYPESREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT GetSupportedResourceTypesRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetSupportedResourceTypesRequest();
+				~GetSupportedResourceTypesRequest();
+
+
+            private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESREQUEST_H_

config/include/alibabacloud/config/model/GetSupportedResourceTypesResult.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_GETSUPPORTEDRESOURCETYPESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESRESULT_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 GetSupportedResourceTypesResult : public ServiceResult
+			{
+			public:
+
+
+				GetSupportedResourceTypesResult();
+				explicit GetSupportedResourceTypesResult(const std::string &payload);
+				~GetSupportedResourceTypesResult();
+				std::vector<std::string> getResourceTypes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> resourceTypes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESRESULT_H_

config/include/alibabacloud/config/model/ListConfigRulesRequest.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_LISTCONFIGRULESREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_LISTCONFIGRULESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT ListConfigRulesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListConfigRulesRequest();
+				~ListConfigRulesRequest();
+
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				std::string getMessageType()const;
+				void setMessageType(const std::string& messageType);
+				std::string getConfigRuleState()const;
+				void setConfigRuleState(const std::string& configRuleState);
+				int getRiskLevel()const;
+				void setRiskLevel(int riskLevel);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getComplianceType()const;
+				void setComplianceType(const std::string& complianceType);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				bool multiAccount_;
+				std::string messageType_;
+				std::string configRuleState_;
+				int riskLevel_;
+				int pageNumber_;
+				int pageSize_;
+				std::string complianceType_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTCONFIGRULESREQUEST_H_

config/include/alibabacloud/config/model/ListConfigRulesResult.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_LISTCONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_LISTCONFIGRULESRESULT_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 ListConfigRulesResult : public ServiceResult
+			{
+			public:
+				struct ConfigRules
+				{
+					struct ConfigRule
+					{
+						struct Compliance
+						{
+							std::string complianceType;
+							int count;
+						};
+						struct CreateBy
+						{
+							std::string creatorId;
+							std::string configRuleSceneName;
+							std::string configRuleSceneId;
+							std::string creatorType;
+							std::string creatorName;
+						};
+						std::string configRuleId;
+						long accountId;
+						std::string description;
+						Compliance compliance;
+						std::string configRuleArn;
+						std::string automationType;
+						std::string sourceOwner;
+						CreateBy createBy;
+						std::string sourceIdentifier;
+						std::string configRuleName;
+						int riskLevel;
+						std::string configRuleState;
+					};
+					long totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<ConfigRule> configRuleList;
+				};
+
+
+				ListConfigRulesResult();
+				explicit ListConfigRulesResult(const std::string &payload);
+				~ListConfigRulesResult();
+				ConfigRules getConfigRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ConfigRules configRules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTCONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/ListDiscoveredResourcesRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_LISTDISCOVEREDRESOURCESREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_LISTDISCOVEREDRESOURCESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT ListDiscoveredResourcesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListDiscoveredResourcesRequest();
+				~ListDiscoveredResourcesRequest();
+
+				int getResourceDeleted()const;
+				void setResourceDeleted(int resourceDeleted);
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				std::string getRegions()const;
+				void setRegions(const std::string& regions);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getComplianceType()const;
+				void setComplianceType(const std::string& complianceType);
+				std::string getResourceId()const;
+				void setResourceId(const std::string& resourceId);
+				std::string getResourceTypes()const;
+				void setResourceTypes(const std::string& resourceTypes);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				int resourceDeleted_;
+				bool multiAccount_;
+				std::string regions_;
+				int pageNumber_;
+				int pageSize_;
+				std::string complianceType_;
+				std::string resourceId_;
+				std::string resourceTypes_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTDISCOVEREDRESOURCESREQUEST_H_

config/include/alibabacloud/config/model/ListDiscoveredResourcesResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_LISTDISCOVEREDRESOURCESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_LISTDISCOVEREDRESOURCESRESULT_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 ListDiscoveredResourcesResult : public ServiceResult
+			{
+			public:
+				struct DiscoveredResourceProfiles
+				{
+					struct DiscoveredResourceProfile
+					{
+						long accountId;
+						long resourceCreationTime;
+						std::string resourceId;
+						std::string resourceName;
+						std::string region;
+						std::string resourceStatus;
+						std::string resourceType;
+						int resourceDeleted;
+						std::string tags;
+					};
+					int totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<DiscoveredResourceProfile> discoveredResourceProfileList;
+				};
+
+
+				ListDiscoveredResourcesResult();
+				explicit ListDiscoveredResourcesResult(const std::string &payload);
+				~ListDiscoveredResourcesResult();
+				DiscoveredResourceProfiles getDiscoveredResourceProfiles()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				DiscoveredResourceProfiles discoveredResourceProfiles_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_LISTDISCOVEREDRESOURCESRESULT_H_

config/include/alibabacloud/config/model/PutConfigRuleRequest.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PUTCONFIGRULEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT PutConfigRuleRequest : public RpcServiceRequest
+			{
+
+			public:
+				PutConfigRuleRequest();
+				~PutConfigRuleRequest();
+
+				std::string getConfigRuleId()const;
+				void setConfigRuleId(const std::string& configRuleId);
+				bool getMultiAccount()const;
+				void setMultiAccount(bool multiAccount);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getSourceIdentifier()const;
+				void setSourceIdentifier(const std::string& sourceIdentifier);
+				std::string getSourceMaximumExecutionFrequency()const;
+				void setSourceMaximumExecutionFrequency(const std::string& sourceMaximumExecutionFrequency);
+				std::string getScopeComplianceResourceTypes()const;
+				void setScopeComplianceResourceTypes(const std::string& scopeComplianceResourceTypes);
+				std::string getSourceDetailMessageType()const;
+				void setSourceDetailMessageType(const std::string& sourceDetailMessageType);
+				int getRiskLevel()const;
+				void setRiskLevel(int riskLevel);
+				std::string getSourceOwner()const;
+				void setSourceOwner(const std::string& sourceOwner);
+				std::string getInputParameters()const;
+				void setInputParameters(const std::string& inputParameters);
+				std::string getConfigRuleName()const;
+				void setConfigRuleName(const std::string& configRuleName);
+				std::string getScopeComplianceResourceId()const;
+				void setScopeComplianceResourceId(const std::string& scopeComplianceResourceId);
+				long getMemberId()const;
+				void setMemberId(long memberId);
+
+            private:
+				std::string configRuleId_;
+				bool multiAccount_;
+				std::string clientToken_;
+				std::string description_;
+				std::string sourceIdentifier_;
+				std::string sourceMaximumExecutionFrequency_;
+				std::string scopeComplianceResourceTypes_;
+				std::string sourceDetailMessageType_;
+				int riskLevel_;
+				std::string sourceOwner_;
+				std::string inputParameters_;
+				std::string configRuleName_;
+				std::string scopeComplianceResourceId_;
+				long memberId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULEREQUEST_H_

config/include/alibabacloud/config/model/PutConfigRuleResult.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_PUTCONFIGRULERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULERESULT_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 PutConfigRuleResult : public ServiceResult
+			{
+			public:
+
+
+				PutConfigRuleResult();
+				explicit PutConfigRuleResult(const std::string &payload);
+				~PutConfigRuleResult();
+				std::string getConfigRuleId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string configRuleId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULERESULT_H_

config/include/alibabacloud/config/model/PutConfigurationRecorderRequest.h

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

config/include/alibabacloud/config/model/PutConfigurationRecorderResult.h

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

config/include/alibabacloud/config/model/PutDeliveryChannelRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT PutDeliveryChannelRequest : public RpcServiceRequest
+			{
+
+			public:
+				PutDeliveryChannelRequest();
+				~PutDeliveryChannelRequest();
+
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getDeliveryChannelTargetArn()const;
+				void setDeliveryChannelTargetArn(const std::string& deliveryChannelTargetArn);
+				std::string getDeliveryChannelCondition()const;
+				void setDeliveryChannelCondition(const std::string& deliveryChannelCondition);
+				std::string getDeliveryChannelAssumeRoleArn()const;
+				void setDeliveryChannelAssumeRoleArn(const std::string& deliveryChannelAssumeRoleArn);
+				std::string getDeliveryChannelName()const;
+				void setDeliveryChannelName(const std::string& deliveryChannelName);
+				std::string getDeliveryChannelId()const;
+				void setDeliveryChannelId(const std::string& deliveryChannelId);
+				std::string getDeliveryChannelType()const;
+				void setDeliveryChannelType(const std::string& deliveryChannelType);
+				int getStatus()const;
+				void setStatus(int status);
+
+            private:
+				std::string clientToken_;
+				std::string description_;
+				std::string deliveryChannelTargetArn_;
+				std::string deliveryChannelCondition_;
+				std::string deliveryChannelAssumeRoleArn_;
+				std::string deliveryChannelName_;
+				std::string deliveryChannelId_;
+				std::string deliveryChannelType_;
+				int status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELREQUEST_H_

config/include/alibabacloud/config/model/PutDeliveryChannelResult.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_PUTDELIVERYCHANNELRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELRESULT_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 PutDeliveryChannelResult : public ServiceResult
+			{
+			public:
+
+
+				PutDeliveryChannelResult();
+				explicit PutDeliveryChannelResult(const std::string &payload);
+				~PutDeliveryChannelResult();
+				std::string getDeliveryChannelId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string deliveryChannelId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELRESULT_H_

config/include/alibabacloud/config/model/PutEvaluationsRequest.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_PUTEVALUATIONSREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_PUTEVALUATIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/config/ConfigExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Config
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CONFIG_EXPORT PutEvaluationsRequest : public RpcServiceRequest
+			{
+
+			public:
+				PutEvaluationsRequest();
+				~PutEvaluationsRequest();
+
+				std::string getEvaluations()const;
+				void setEvaluations(const std::string& evaluations);
+				std::string getResultToken()const;
+				void setResultToken(const std::string& resultToken);
+
+            private:
+				std::string evaluations_;
+				std::string resultToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTEVALUATIONSREQUEST_H_

config/include/alibabacloud/config/model/PutEvaluationsResult.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_PUTEVALUATIONSRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_PUTEVALUATIONSRESULT_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 PutEvaluationsResult : public ServiceResult
+			{
+			public:
+
+
+				PutEvaluationsResult();
+				explicit PutEvaluationsResult(const std::string &payload);
+				~PutEvaluationsResult();
+				bool getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTEVALUATIONSRESULT_H_

config/include/alibabacloud/config/model/StartConfigRuleEvaluationRequest.h

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

config/include/alibabacloud/config/model/StartConfigRuleEvaluationResult.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_STARTCONFIGRULEEVALUATIONRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_STARTCONFIGRULEEVALUATIONRESULT_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 StartConfigRuleEvaluationResult : public ServiceResult
+			{
+			public:
+
+
+				StartConfigRuleEvaluationResult();
+				explicit StartConfigRuleEvaluationResult(const std::string &payload);
+				~StartConfigRuleEvaluationResult();
+				bool getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_STARTCONFIGRULEEVALUATIONRESULT_H_

config/include/alibabacloud/config/model/StartConfigurationRecorderRequest.h

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

config/include/alibabacloud/config/model/StartConfigurationRecorderResult.h

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

config/include/alibabacloud/config/model/StopConfigRulesRequest.h

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

config/include/alibabacloud/config/model/StopConfigRulesResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_STOPCONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_STOPCONFIGRULESRESULT_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 StopConfigRulesResult : public ServiceResult
+			{
+			public:
+				struct OperateRuleResult
+				{
+					struct OperateRuleItem
+					{
+						std::string configRuleId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateRuleItem> operateRuleItemList;
+				};
+
+
+				StopConfigRulesResult();
+				explicit StopConfigRulesResult(const std::string &payload);
+				~StopConfigRulesResult();
+				OperateRuleResult getOperateRuleResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OperateRuleResult operateRuleResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_STOPCONFIGRULESRESULT_H_

config/src/ConfigClient.cc

@@ -0,0 +1,881 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ConfigClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "Config";
+}
+
+ConfigClient::ConfigClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "config");
+}
+
+ConfigClient::ConfigClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "config");
+}
+
+ConfigClient::ConfigClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "config");
+}
+
+ConfigClient::~ConfigClient()
+{}
+
+ConfigClient::ActiveConfigRulesOutcome ConfigClient::activeConfigRules(const ActiveConfigRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ActiveConfigRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ActiveConfigRulesOutcome(ActiveConfigRulesResult(outcome.result()));
+	else
+		return ActiveConfigRulesOutcome(outcome.error());
+}
+
+void ConfigClient::activeConfigRulesAsync(const ActiveConfigRulesRequest& request, const ActiveConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, activeConfigRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::ActiveConfigRulesOutcomeCallable ConfigClient::activeConfigRulesCallable(const ActiveConfigRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ActiveConfigRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->activeConfigRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DeleteConfigRulesOutcome ConfigClient::deleteConfigRules(const DeleteConfigRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteConfigRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteConfigRulesOutcome(DeleteConfigRulesResult(outcome.result()));
+	else
+		return DeleteConfigRulesOutcome(outcome.error());
+}
+
+void ConfigClient::deleteConfigRulesAsync(const DeleteConfigRulesRequest& request, const DeleteConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteConfigRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DeleteConfigRulesOutcomeCallable ConfigClient::deleteConfigRulesCallable(const DeleteConfigRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteConfigRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteConfigRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeComplianceOutcome ConfigClient::describeCompliance(const DescribeComplianceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeComplianceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeComplianceOutcome(DescribeComplianceResult(outcome.result()));
+	else
+		return DescribeComplianceOutcome(outcome.error());
+}
+
+void ConfigClient::describeComplianceAsync(const DescribeComplianceRequest& request, const DescribeComplianceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCompliance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeComplianceOutcomeCallable ConfigClient::describeComplianceCallable(const DescribeComplianceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeComplianceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCompliance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeComplianceSummaryOutcome ConfigClient::describeComplianceSummary(const DescribeComplianceSummaryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeComplianceSummaryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeComplianceSummaryOutcome(DescribeComplianceSummaryResult(outcome.result()));
+	else
+		return DescribeComplianceSummaryOutcome(outcome.error());
+}
+
+void ConfigClient::describeComplianceSummaryAsync(const DescribeComplianceSummaryRequest& request, const DescribeComplianceSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeComplianceSummary(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeComplianceSummaryOutcomeCallable ConfigClient::describeComplianceSummaryCallable(const DescribeComplianceSummaryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeComplianceSummaryOutcome()>>(
+			[this, request]()
+			{
+			return this->describeComplianceSummary(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeConfigRuleOutcome ConfigClient::describeConfigRule(const DescribeConfigRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeConfigRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeConfigRuleOutcome(DescribeConfigRuleResult(outcome.result()));
+	else
+		return DescribeConfigRuleOutcome(outcome.error());
+}
+
+void ConfigClient::describeConfigRuleAsync(const DescribeConfigRuleRequest& request, const DescribeConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeConfigRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeConfigRuleOutcomeCallable ConfigClient::describeConfigRuleCallable(const DescribeConfigRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeConfigRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->describeConfigRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeConfigurationRecorderOutcome ConfigClient::describeConfigurationRecorder(const DescribeConfigurationRecorderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeConfigurationRecorderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeConfigurationRecorderOutcome(DescribeConfigurationRecorderResult(outcome.result()));
+	else
+		return DescribeConfigurationRecorderOutcome(outcome.error());
+}
+
+void ConfigClient::describeConfigurationRecorderAsync(const DescribeConfigurationRecorderRequest& request, const DescribeConfigurationRecorderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeConfigurationRecorder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeConfigurationRecorderOutcomeCallable ConfigClient::describeConfigurationRecorderCallable(const DescribeConfigurationRecorderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeConfigurationRecorderOutcome()>>(
+			[this, request]()
+			{
+			return this->describeConfigurationRecorder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeDeliveryChannelsOutcome ConfigClient::describeDeliveryChannels(const DescribeDeliveryChannelsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDeliveryChannelsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDeliveryChannelsOutcome(DescribeDeliveryChannelsResult(outcome.result()));
+	else
+		return DescribeDeliveryChannelsOutcome(outcome.error());
+}
+
+void ConfigClient::describeDeliveryChannelsAsync(const DescribeDeliveryChannelsRequest& request, const DescribeDeliveryChannelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDeliveryChannels(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeDeliveryChannelsOutcomeCallable ConfigClient::describeDeliveryChannelsCallable(const DescribeDeliveryChannelsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDeliveryChannelsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDeliveryChannels(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeDiscoveredResourceOutcome ConfigClient::describeDiscoveredResource(const DescribeDiscoveredResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDiscoveredResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDiscoveredResourceOutcome(DescribeDiscoveredResourceResult(outcome.result()));
+	else
+		return DescribeDiscoveredResourceOutcome(outcome.error());
+}
+
+void ConfigClient::describeDiscoveredResourceAsync(const DescribeDiscoveredResourceRequest& request, const DescribeDiscoveredResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDiscoveredResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeDiscoveredResourceOutcomeCallable ConfigClient::describeDiscoveredResourceCallable(const DescribeDiscoveredResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDiscoveredResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDiscoveredResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::DescribeEvaluationResultsOutcome ConfigClient::describeEvaluationResults(const DescribeEvaluationResultsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeEvaluationResultsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeEvaluationResultsOutcome(DescribeEvaluationResultsResult(outcome.result()));
+	else
+		return DescribeEvaluationResultsOutcome(outcome.error());
+}
+
+void ConfigClient::describeEvaluationResultsAsync(const DescribeEvaluationResultsRequest& request, const DescribeEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeEvaluationResults(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::DescribeEvaluationResultsOutcomeCallable ConfigClient::describeEvaluationResultsCallable(const DescribeEvaluationResultsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeEvaluationResultsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeEvaluationResults(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetDiscoveredResourceCountsOutcome ConfigClient::getDiscoveredResourceCounts(const GetDiscoveredResourceCountsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDiscoveredResourceCountsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDiscoveredResourceCountsOutcome(GetDiscoveredResourceCountsResult(outcome.result()));
+	else
+		return GetDiscoveredResourceCountsOutcome(outcome.error());
+}
+
+void ConfigClient::getDiscoveredResourceCountsAsync(const GetDiscoveredResourceCountsRequest& request, const GetDiscoveredResourceCountsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDiscoveredResourceCounts(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetDiscoveredResourceCountsOutcomeCallable ConfigClient::getDiscoveredResourceCountsCallable(const GetDiscoveredResourceCountsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDiscoveredResourceCountsOutcome()>>(
+			[this, request]()
+			{
+			return this->getDiscoveredResourceCounts(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetDiscoveredResourceSummaryOutcome ConfigClient::getDiscoveredResourceSummary(const GetDiscoveredResourceSummaryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDiscoveredResourceSummaryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDiscoveredResourceSummaryOutcome(GetDiscoveredResourceSummaryResult(outcome.result()));
+	else
+		return GetDiscoveredResourceSummaryOutcome(outcome.error());
+}
+
+void ConfigClient::getDiscoveredResourceSummaryAsync(const GetDiscoveredResourceSummaryRequest& request, const GetDiscoveredResourceSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDiscoveredResourceSummary(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetDiscoveredResourceSummaryOutcomeCallable ConfigClient::getDiscoveredResourceSummaryCallable(const GetDiscoveredResourceSummaryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDiscoveredResourceSummaryOutcome()>>(
+			[this, request]()
+			{
+			return this->getDiscoveredResourceSummary(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetResourceComplianceTimelineOutcome ConfigClient::getResourceComplianceTimeline(const GetResourceComplianceTimelineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceComplianceTimelineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceComplianceTimelineOutcome(GetResourceComplianceTimelineResult(outcome.result()));
+	else
+		return GetResourceComplianceTimelineOutcome(outcome.error());
+}
+
+void ConfigClient::getResourceComplianceTimelineAsync(const GetResourceComplianceTimelineRequest& request, const GetResourceComplianceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceComplianceTimeline(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetResourceComplianceTimelineOutcomeCallable ConfigClient::getResourceComplianceTimelineCallable(const GetResourceComplianceTimelineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceComplianceTimelineOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceComplianceTimeline(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetResourceConfigurationTimelineOutcome ConfigClient::getResourceConfigurationTimeline(const GetResourceConfigurationTimelineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceConfigurationTimelineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceConfigurationTimelineOutcome(GetResourceConfigurationTimelineResult(outcome.result()));
+	else
+		return GetResourceConfigurationTimelineOutcome(outcome.error());
+}
+
+void ConfigClient::getResourceConfigurationTimelineAsync(const GetResourceConfigurationTimelineRequest& request, const GetResourceConfigurationTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceConfigurationTimeline(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetResourceConfigurationTimelineOutcomeCallable ConfigClient::getResourceConfigurationTimelineCallable(const GetResourceConfigurationTimelineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceConfigurationTimelineOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceConfigurationTimeline(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::GetSupportedResourceTypesOutcome ConfigClient::getSupportedResourceTypes(const GetSupportedResourceTypesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetSupportedResourceTypesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetSupportedResourceTypesOutcome(GetSupportedResourceTypesResult(outcome.result()));
+	else
+		return GetSupportedResourceTypesOutcome(outcome.error());
+}
+
+void ConfigClient::getSupportedResourceTypesAsync(const GetSupportedResourceTypesRequest& request, const GetSupportedResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getSupportedResourceTypes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::GetSupportedResourceTypesOutcomeCallable ConfigClient::getSupportedResourceTypesCallable(const GetSupportedResourceTypesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetSupportedResourceTypesOutcome()>>(
+			[this, request]()
+			{
+			return this->getSupportedResourceTypes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::ListConfigRulesOutcome ConfigClient::listConfigRules(const ListConfigRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListConfigRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListConfigRulesOutcome(ListConfigRulesResult(outcome.result()));
+	else
+		return ListConfigRulesOutcome(outcome.error());
+}
+
+void ConfigClient::listConfigRulesAsync(const ListConfigRulesRequest& request, const ListConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listConfigRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::ListConfigRulesOutcomeCallable ConfigClient::listConfigRulesCallable(const ListConfigRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListConfigRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->listConfigRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::ListDiscoveredResourcesOutcome ConfigClient::listDiscoveredResources(const ListDiscoveredResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListDiscoveredResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListDiscoveredResourcesOutcome(ListDiscoveredResourcesResult(outcome.result()));
+	else
+		return ListDiscoveredResourcesOutcome(outcome.error());
+}
+
+void ConfigClient::listDiscoveredResourcesAsync(const ListDiscoveredResourcesRequest& request, const ListDiscoveredResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listDiscoveredResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::ListDiscoveredResourcesOutcomeCallable ConfigClient::listDiscoveredResourcesCallable(const ListDiscoveredResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListDiscoveredResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listDiscoveredResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::PutConfigRuleOutcome ConfigClient::putConfigRule(const PutConfigRuleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PutConfigRuleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PutConfigRuleOutcome(PutConfigRuleResult(outcome.result()));
+	else
+		return PutConfigRuleOutcome(outcome.error());
+}
+
+void ConfigClient::putConfigRuleAsync(const PutConfigRuleRequest& request, const PutConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, putConfigRule(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::PutConfigRuleOutcomeCallable ConfigClient::putConfigRuleCallable(const PutConfigRuleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PutConfigRuleOutcome()>>(
+			[this, request]()
+			{
+			return this->putConfigRule(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::PutConfigurationRecorderOutcome ConfigClient::putConfigurationRecorder(const PutConfigurationRecorderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PutConfigurationRecorderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PutConfigurationRecorderOutcome(PutConfigurationRecorderResult(outcome.result()));
+	else
+		return PutConfigurationRecorderOutcome(outcome.error());
+}
+
+void ConfigClient::putConfigurationRecorderAsync(const PutConfigurationRecorderRequest& request, const PutConfigurationRecorderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, putConfigurationRecorder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::PutConfigurationRecorderOutcomeCallable ConfigClient::putConfigurationRecorderCallable(const PutConfigurationRecorderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PutConfigurationRecorderOutcome()>>(
+			[this, request]()
+			{
+			return this->putConfigurationRecorder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::PutDeliveryChannelOutcome ConfigClient::putDeliveryChannel(const PutDeliveryChannelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PutDeliveryChannelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PutDeliveryChannelOutcome(PutDeliveryChannelResult(outcome.result()));
+	else
+		return PutDeliveryChannelOutcome(outcome.error());
+}
+
+void ConfigClient::putDeliveryChannelAsync(const PutDeliveryChannelRequest& request, const PutDeliveryChannelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, putDeliveryChannel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::PutDeliveryChannelOutcomeCallable ConfigClient::putDeliveryChannelCallable(const PutDeliveryChannelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PutDeliveryChannelOutcome()>>(
+			[this, request]()
+			{
+			return this->putDeliveryChannel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::PutEvaluationsOutcome ConfigClient::putEvaluations(const PutEvaluationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PutEvaluationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PutEvaluationsOutcome(PutEvaluationsResult(outcome.result()));
+	else
+		return PutEvaluationsOutcome(outcome.error());
+}
+
+void ConfigClient::putEvaluationsAsync(const PutEvaluationsRequest& request, const PutEvaluationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, putEvaluations(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::PutEvaluationsOutcomeCallable ConfigClient::putEvaluationsCallable(const PutEvaluationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PutEvaluationsOutcome()>>(
+			[this, request]()
+			{
+			return this->putEvaluations(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::StartConfigRuleEvaluationOutcome ConfigClient::startConfigRuleEvaluation(const StartConfigRuleEvaluationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartConfigRuleEvaluationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartConfigRuleEvaluationOutcome(StartConfigRuleEvaluationResult(outcome.result()));
+	else
+		return StartConfigRuleEvaluationOutcome(outcome.error());
+}
+
+void ConfigClient::startConfigRuleEvaluationAsync(const StartConfigRuleEvaluationRequest& request, const StartConfigRuleEvaluationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startConfigRuleEvaluation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::StartConfigRuleEvaluationOutcomeCallable ConfigClient::startConfigRuleEvaluationCallable(const StartConfigRuleEvaluationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartConfigRuleEvaluationOutcome()>>(
+			[this, request]()
+			{
+			return this->startConfigRuleEvaluation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::StartConfigurationRecorderOutcome ConfigClient::startConfigurationRecorder(const StartConfigurationRecorderRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartConfigurationRecorderOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartConfigurationRecorderOutcome(StartConfigurationRecorderResult(outcome.result()));
+	else
+		return StartConfigurationRecorderOutcome(outcome.error());
+}
+
+void ConfigClient::startConfigurationRecorderAsync(const StartConfigurationRecorderRequest& request, const StartConfigurationRecorderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startConfigurationRecorder(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::StartConfigurationRecorderOutcomeCallable ConfigClient::startConfigurationRecorderCallable(const StartConfigurationRecorderRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartConfigurationRecorderOutcome()>>(
+			[this, request]()
+			{
+			return this->startConfigurationRecorder(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ConfigClient::StopConfigRulesOutcome ConfigClient::stopConfigRules(const StopConfigRulesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopConfigRulesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopConfigRulesOutcome(StopConfigRulesResult(outcome.result()));
+	else
+		return StopConfigRulesOutcome(outcome.error());
+}
+
+void ConfigClient::stopConfigRulesAsync(const StopConfigRulesRequest& request, const StopConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopConfigRules(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ConfigClient::StopConfigRulesOutcomeCallable ConfigClient::stopConfigRulesCallable(const StopConfigRulesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopConfigRulesOutcome()>>(
+			[this, request]()
+			{
+			return this->stopConfigRules(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

config/src/model/ActiveConfigRulesRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ActiveConfigRulesRequest.h>
+
+using AlibabaCloud::Config::Model::ActiveConfigRulesRequest;
+
+ActiveConfigRulesRequest::ActiveConfigRulesRequest() :
+	RpcServiceRequest("config", "2019-01-08", "ActiveConfigRules")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ActiveConfigRulesRequest::~ActiveConfigRulesRequest()
+{}
+
+std::string ActiveConfigRulesRequest::getConfigRuleIds()const
+{
+	return configRuleIds_;
+}
+
+void ActiveConfigRulesRequest::setConfigRuleIds(const std::string& configRuleIds)
+{
+	configRuleIds_ = configRuleIds;
+	setParameter("ConfigRuleIds", configRuleIds);
+}
+

config/src/model/ActiveConfigRulesResult.cc

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

config/src/model/DeleteConfigRulesRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DeleteConfigRulesRequest.h>
+
+using AlibabaCloud::Config::Model::DeleteConfigRulesRequest;
+
+DeleteConfigRulesRequest::DeleteConfigRulesRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DeleteConfigRules")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteConfigRulesRequest::~DeleteConfigRulesRequest()
+{}
+
+std::string DeleteConfigRulesRequest::getConfigRuleIds()const
+{
+	return configRuleIds_;
+}
+
+void DeleteConfigRulesRequest::setConfigRuleIds(const std::string& configRuleIds)
+{
+	configRuleIds_ = configRuleIds;
+	setParameter("ConfigRuleIds", configRuleIds);
+}
+

config/src/model/DeleteConfigRulesResult.cc

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

config/src/model/DescribeComplianceRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeComplianceRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeComplianceRequest;
+
+DescribeComplianceRequest::DescribeComplianceRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DescribeCompliance")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeComplianceRequest::~DescribeComplianceRequest()
+{}
+
+std::string DescribeComplianceRequest::getConfigRuleId()const
+{
+	return configRuleId_;
+}
+
+void DescribeComplianceRequest::setConfigRuleId(const std::string& configRuleId)
+{
+	configRuleId_ = configRuleId;
+	setParameter("ConfigRuleId", configRuleId);
+}
+
+std::string DescribeComplianceRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void DescribeComplianceRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+bool DescribeComplianceRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void DescribeComplianceRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+std::string DescribeComplianceRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void DescribeComplianceRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string DescribeComplianceRequest::getComplianceType()const
+{
+	return complianceType_;
+}
+
+void DescribeComplianceRequest::setComplianceType(const std::string& complianceType)
+{
+	complianceType_ = complianceType;
+	setParameter("ComplianceType", complianceType);
+}
+
+long DescribeComplianceRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void DescribeComplianceRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/DescribeComplianceResult.cc

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

config/src/model/DescribeComplianceSummaryRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeComplianceSummaryRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeComplianceSummaryRequest;
+
+DescribeComplianceSummaryRequest::DescribeComplianceSummaryRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DescribeComplianceSummary")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeComplianceSummaryRequest::~DescribeComplianceSummaryRequest()
+{}
+
+bool DescribeComplianceSummaryRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void DescribeComplianceSummaryRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+long DescribeComplianceSummaryRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void DescribeComplianceSummaryRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/DescribeComplianceSummaryResult.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/DescribeComplianceSummaryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeComplianceSummaryResult::DescribeComplianceSummaryResult() :
+	ServiceResult()
+{}
+
+DescribeComplianceSummaryResult::DescribeComplianceSummaryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeComplianceSummaryResult::~DescribeComplianceSummaryResult()
+{}
+
+void DescribeComplianceSummaryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto complianceSummaryNode = value["ComplianceSummary"];
+	auto complianceSummaryByConfigRuleNode = complianceSummaryNode["ComplianceSummaryByConfigRule"];
+	if(!complianceSummaryByConfigRuleNode["ComplianceSummaryTimestamp"].isNull())
+		complianceSummary_.complianceSummaryByConfigRule.complianceSummaryTimestamp = std::stol(complianceSummaryByConfigRuleNode["ComplianceSummaryTimestamp"].asString());
+	if(!complianceSummaryByConfigRuleNode["CompliantCount"].isNull())
+		complianceSummary_.complianceSummaryByConfigRule.compliantCount = std::stoi(complianceSummaryByConfigRuleNode["CompliantCount"].asString());
+	if(!complianceSummaryByConfigRuleNode["NonCompliantCount"].isNull())
+		complianceSummary_.complianceSummaryByConfigRule.nonCompliantCount = std::stoi(complianceSummaryByConfigRuleNode["NonCompliantCount"].asString());
+	if(!complianceSummaryByConfigRuleNode["TotalCount"].isNull())
+		complianceSummary_.complianceSummaryByConfigRule.totalCount = std::stol(complianceSummaryByConfigRuleNode["TotalCount"].asString());
+	auto complianceSummaryByResourceNode = complianceSummaryNode["ComplianceSummaryByResource"];
+	if(!complianceSummaryByResourceNode["ComplianceSummaryTimestamp"].isNull())
+		complianceSummary_.complianceSummaryByResource.complianceSummaryTimestamp = std::stol(complianceSummaryByResourceNode["ComplianceSummaryTimestamp"].asString());
+	if(!complianceSummaryByResourceNode["CompliantCount"].isNull())
+		complianceSummary_.complianceSummaryByResource.compliantCount = std::stoi(complianceSummaryByResourceNode["CompliantCount"].asString());
+	if(!complianceSummaryByResourceNode["NonCompliantCount"].isNull())
+		complianceSummary_.complianceSummaryByResource.nonCompliantCount = std::stoi(complianceSummaryByResourceNode["NonCompliantCount"].asString());
+	if(!complianceSummaryByResourceNode["TotalCount"].isNull())
+		complianceSummary_.complianceSummaryByResource.totalCount = std::stol(complianceSummaryByResourceNode["TotalCount"].asString());
+
+}
+
+DescribeComplianceSummaryResult::ComplianceSummary DescribeComplianceSummaryResult::getComplianceSummary()const
+{
+	return complianceSummary_;
+}
+

config/src/model/DescribeConfigRuleRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeConfigRuleRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeConfigRuleRequest;
+
+DescribeConfigRuleRequest::DescribeConfigRuleRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DescribeConfigRule")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeConfigRuleRequest::~DescribeConfigRuleRequest()
+{}
+
+std::string DescribeConfigRuleRequest::getConfigRuleId()const
+{
+	return configRuleId_;
+}
+
+void DescribeConfigRuleRequest::setConfigRuleId(const std::string& configRuleId)
+{
+	configRuleId_ = configRuleId;
+	setParameter("ConfigRuleId", configRuleId);
+}
+
+bool DescribeConfigRuleRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void DescribeConfigRuleRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+long DescribeConfigRuleRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void DescribeConfigRuleRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/DescribeConfigRuleResult.cc

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeConfigRuleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeConfigRuleResult::DescribeConfigRuleResult() :
+	ServiceResult()
+{}
+
+DescribeConfigRuleResult::DescribeConfigRuleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeConfigRuleResult::~DescribeConfigRuleResult()
+{}
+
+void DescribeConfigRuleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configRuleNode = value["ConfigRule"];
+	if(!configRuleNode["ConfigRuleArn"].isNull())
+		configRule_.configRuleArn = configRuleNode["ConfigRuleArn"].asString();
+	if(!configRuleNode["ConfigRuleId"].isNull())
+		configRule_.configRuleId = configRuleNode["ConfigRuleId"].asString();
+	if(!configRuleNode["ConfigRuleName"].isNull())
+		configRule_.configRuleName = configRuleNode["ConfigRuleName"].asString();
+	if(!configRuleNode["ConfigRuleState"].isNull())
+		configRule_.configRuleState = configRuleNode["ConfigRuleState"].asString();
+	if(!configRuleNode["CreateTimestamp"].isNull())
+		configRule_.createTimestamp = std::stol(configRuleNode["CreateTimestamp"].asString());
+	if(!configRuleNode["Description"].isNull())
+		configRule_.description = configRuleNode["Description"].asString();
+	if(!configRuleNode["InputParameters"].isNull())
+		configRule_.inputParameters = configRuleNode["InputParameters"].asString();
+	if(!configRuleNode["ModifiedTimestamp"].isNull())
+		configRule_.modifiedTimestamp = std::stol(configRuleNode["ModifiedTimestamp"].asString());
+	if(!configRuleNode["RiskLevel"].isNull())
+		configRule_.riskLevel = std::stoi(configRuleNode["RiskLevel"].asString());
+	auto createByNode = configRuleNode["CreateBy"];
+	if(!createByNode["CreatorType"].isNull())
+		configRule_.createBy.creatorType = createByNode["CreatorType"].asString();
+	if(!createByNode["CreatorId"].isNull())
+		configRule_.createBy.creatorId = createByNode["CreatorId"].asString();
+	if(!createByNode["CreatorName"].isNull())
+		configRule_.createBy.creatorName = createByNode["CreatorName"].asString();
+	if(!createByNode["ConfigRuleSceneId"].isNull())
+		configRule_.createBy.configRuleSceneId = createByNode["ConfigRuleSceneId"].asString();
+	if(!createByNode["ConfigRuleSceneName"].isNull())
+		configRule_.createBy.configRuleSceneName = createByNode["ConfigRuleSceneName"].asString();
+	auto configRuleEvaluationStatusNode = configRuleNode["ConfigRuleEvaluationStatus"];
+	if(!configRuleEvaluationStatusNode["FirstActivatedTimestamp"].isNull())
+		configRule_.configRuleEvaluationStatus.firstActivatedTimestamp = std::stol(configRuleEvaluationStatusNode["FirstActivatedTimestamp"].asString());
+	if(!configRuleEvaluationStatusNode["FirstEvaluationStarted"].isNull())
+		configRule_.configRuleEvaluationStatus.firstEvaluationStarted = configRuleEvaluationStatusNode["FirstEvaluationStarted"].asString() == "true";
+	if(!configRuleEvaluationStatusNode["LastErrorCode"].isNull())
+		configRule_.configRuleEvaluationStatus.lastErrorCode = configRuleEvaluationStatusNode["LastErrorCode"].asString();
+	if(!configRuleEvaluationStatusNode["LastErrorMessage"].isNull())
+		configRule_.configRuleEvaluationStatus.lastErrorMessage = configRuleEvaluationStatusNode["LastErrorMessage"].asString();
+	if(!configRuleEvaluationStatusNode["LastFailedEvaluationTimestamp"].isNull())
+		configRule_.configRuleEvaluationStatus.lastFailedEvaluationTimestamp = std::stol(configRuleEvaluationStatusNode["LastFailedEvaluationTimestamp"].asString());
+	if(!configRuleEvaluationStatusNode["LastFailedInvocationTimestamp"].isNull())
+		configRule_.configRuleEvaluationStatus.lastFailedInvocationTimestamp = std::stol(configRuleEvaluationStatusNode["LastFailedInvocationTimestamp"].asString());
+	if(!configRuleEvaluationStatusNode["LastSuccessfulEvaluationTimestamp"].isNull())
+		configRule_.configRuleEvaluationStatus.lastSuccessfulEvaluationTimestamp = std::stol(configRuleEvaluationStatusNode["LastSuccessfulEvaluationTimestamp"].asString());
+	if(!configRuleEvaluationStatusNode["LastSuccessfulInvocationTimestamp"].isNull())
+		configRule_.configRuleEvaluationStatus.lastSuccessfulInvocationTimestamp = std::stol(configRuleEvaluationStatusNode["LastSuccessfulInvocationTimestamp"].asString());
+	auto managedRuleNode = configRuleNode["ManagedRule"];
+	if(!managedRuleNode["ManagedRuleName"].isNull())
+		configRule_.managedRule.managedRuleName = managedRuleNode["ManagedRuleName"].asString();
+	if(!managedRuleNode["Description"].isNull())
+		configRule_.managedRule.description = managedRuleNode["Description"].asString();
+	if(!managedRuleNode["Identifier"].isNull())
+		configRule_.managedRule.identifier = managedRuleNode["Identifier"].asString();
+	if(!managedRuleNode["CompulsoryInputParameterDetails"].isNull())
+		configRule_.managedRule.compulsoryInputParameterDetails = managedRuleNode["CompulsoryInputParameterDetails"].asString();
+	if(!managedRuleNode["OptionalInputParameterDetails"].isNull())
+		configRule_.managedRule.optionalInputParameterDetails = managedRuleNode["OptionalInputParameterDetails"].asString();
+	if(!managedRuleNode["HelpUrl"].isNull())
+		configRule_.managedRule.helpUrl = managedRuleNode["HelpUrl"].asString();
+	auto allSourceDetailsNode = managedRuleNode["SourceDetails"]["SourceDetailsItem"];
+	for (auto managedRuleNodeSourceDetailsSourceDetailsItem : allSourceDetailsNode)
+	{
+		ConfigRule::ManagedRule::SourceDetailsItem sourceDetailsItemObject;
+		if(!managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].isNull())
+			sourceDetailsItemObject.eventSource = managedRuleNodeSourceDetailsSourceDetailsItem["EventSource"].asString();
+		if(!managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].isNull())
+			sourceDetailsItemObject.maximumExecutionFrequency = managedRuleNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].asString();
+		if(!managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].isNull())
+			sourceDetailsItemObject.messageType = managedRuleNodeSourceDetailsSourceDetailsItem["MessageType"].asString();
+		configRule_.managedRule.sourceDetails.push_back(sourceDetailsItemObject);
+	}
+		auto allLabels = managedRuleNode["Labels"]["Labels"];
+		for (auto value : allLabels)
+			configRule_.managedRule.labels.push_back(value.asString());
+	auto sourceNode = configRuleNode["Source"];
+	if(!sourceNode["Identifier"].isNull())
+		configRule_.source.identifier = sourceNode["Identifier"].asString();
+	if(!sourceNode["Owner"].isNull())
+		configRule_.source.owner = sourceNode["Owner"].asString();
+	auto allSourceConditionsNode = sourceNode["SourceConditions"]["SourceConditionsItem"];
+	for (auto sourceNodeSourceConditionsSourceConditionsItem : allSourceConditionsNode)
+	{
+		ConfigRule::Source::SourceConditionsItem sourceConditionsItemObject;
+		if(!sourceNodeSourceConditionsSourceConditionsItem["DesiredValue"].isNull())
+			sourceConditionsItemObject.desiredValue = sourceNodeSourceConditionsSourceConditionsItem["DesiredValue"].asString();
+		if(!sourceNodeSourceConditionsSourceConditionsItem["Name"].isNull())
+			sourceConditionsItemObject.name = sourceNodeSourceConditionsSourceConditionsItem["Name"].asString();
+		if(!sourceNodeSourceConditionsSourceConditionsItem["Operator"].isNull())
+			sourceConditionsItemObject._operator = sourceNodeSourceConditionsSourceConditionsItem["Operator"].asString();
+		if(!sourceNodeSourceConditionsSourceConditionsItem["Required"].isNull())
+			sourceConditionsItemObject.required = sourceNodeSourceConditionsSourceConditionsItem["Required"].asString() == "true";
+		if(!sourceNodeSourceConditionsSourceConditionsItem["SelectPath"].isNull())
+			sourceConditionsItemObject.selectPath = sourceNodeSourceConditionsSourceConditionsItem["SelectPath"].asString();
+		if(!sourceNodeSourceConditionsSourceConditionsItem["Tips"].isNull())
+			sourceConditionsItemObject.tips = sourceNodeSourceConditionsSourceConditionsItem["Tips"].asString();
+		configRule_.source.sourceConditions.push_back(sourceConditionsItemObject);
+	}
+	auto allSourceDetails1Node = sourceNode["SourceDetails"]["SourceDetailsItem"];
+	for (auto sourceNodeSourceDetailsSourceDetailsItem : allSourceDetails1Node)
+	{
+		ConfigRule::Source::SourceDetailsItem2 sourceDetailsItem2Object;
+		if(!sourceNodeSourceDetailsSourceDetailsItem["EventSource"].isNull())
+			sourceDetailsItem2Object.eventSource = sourceNodeSourceDetailsSourceDetailsItem["EventSource"].asString();
+		if(!sourceNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].isNull())
+			sourceDetailsItem2Object.maximumExecutionFrequency = sourceNodeSourceDetailsSourceDetailsItem["MaximumExecutionFrequency"].asString();
+		if(!sourceNodeSourceDetailsSourceDetailsItem["MessageType"].isNull())
+			sourceDetailsItem2Object.messageType = sourceNodeSourceDetailsSourceDetailsItem["MessageType"].asString();
+		configRule_.source.sourceDetails1.push_back(sourceDetailsItem2Object);
+	}
+	auto scopeNode = configRuleNode["Scope"];
+	if(!scopeNode["ComplianceResourceId"].isNull())
+		configRule_.scope.complianceResourceId = scopeNode["ComplianceResourceId"].asString();
+		auto allComplianceResourceTypes = scopeNode["ComplianceResourceTypes"]["ComplianceResourceTypes"];
+		for (auto value : allComplianceResourceTypes)
+			configRule_.scope.complianceResourceTypes.push_back(value.asString());
+
+}
+
+DescribeConfigRuleResult::ConfigRule DescribeConfigRuleResult::getConfigRule()const
+{
+	return configRule_;
+}
+

config/src/model/DescribeConfigurationRecorderRequest.cc

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

config/src/model/DescribeConfigurationRecorderResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeConfigurationRecorderResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeConfigurationRecorderResult::DescribeConfigurationRecorderResult() :
+	ServiceResult()
+{}
+
+DescribeConfigurationRecorderResult::DescribeConfigurationRecorderResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeConfigurationRecorderResult::~DescribeConfigurationRecorderResult()
+{}
+
+void DescribeConfigurationRecorderResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configurationRecorderNode = value["ConfigurationRecorder"];
+	if(!configurationRecorderNode["AccountId"].isNull())
+		configurationRecorder_.accountId = std::stol(configurationRecorderNode["AccountId"].asString());
+	if(!configurationRecorderNode["ConfigurationRecorderStatus"].isNull())
+		configurationRecorder_.configurationRecorderStatus = configurationRecorderNode["ConfigurationRecorderStatus"].asString();
+	if(!configurationRecorderNode["OrganizationMasterId"].isNull())
+		configurationRecorder_.organizationMasterId = std::stol(configurationRecorderNode["OrganizationMasterId"].asString());
+	if(!configurationRecorderNode["OrganizationEnableStatus"].isNull())
+		configurationRecorder_.organizationEnableStatus = configurationRecorderNode["OrganizationEnableStatus"].asString();
+		auto allResourceTypes = configurationRecorderNode["ResourceTypes"]["ResourceType"];
+		for (auto value : allResourceTypes)
+			configurationRecorder_.resourceTypes.push_back(value.asString());
+
+}
+
+DescribeConfigurationRecorderResult::ConfigurationRecorder DescribeConfigurationRecorderResult::getConfigurationRecorder()const
+{
+	return configurationRecorder_;
+}
+

config/src/model/DescribeDeliveryChannelsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDeliveryChannelsRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeDeliveryChannelsRequest;
+
+DescribeDeliveryChannelsRequest::DescribeDeliveryChannelsRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DescribeDeliveryChannels")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeDeliveryChannelsRequest::~DescribeDeliveryChannelsRequest()
+{}
+
+std::string DescribeDeliveryChannelsRequest::getDeliveryChannelIds()const
+{
+	return deliveryChannelIds_;
+}
+
+void DescribeDeliveryChannelsRequest::setDeliveryChannelIds(const std::string& deliveryChannelIds)
+{
+	deliveryChannelIds_ = deliveryChannelIds;
+	setParameter("DeliveryChannelIds", deliveryChannelIds);
+}
+

config/src/model/DescribeDeliveryChannelsResult.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeDeliveryChannelsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeDeliveryChannelsResult::DescribeDeliveryChannelsResult() :
+	ServiceResult()
+{}
+
+DescribeDeliveryChannelsResult::DescribeDeliveryChannelsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDeliveryChannelsResult::~DescribeDeliveryChannelsResult()
+{}
+
+void DescribeDeliveryChannelsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDeliveryChannelsNode = value["DeliveryChannels"]["DeliveryChannel"];
+	for (auto valueDeliveryChannelsDeliveryChannel : allDeliveryChannelsNode)
+	{
+		DeliveryChannel deliveryChannelsObject;
+		if(!valueDeliveryChannelsDeliveryChannel["DeliveryChannelId"].isNull())
+			deliveryChannelsObject.deliveryChannelId = valueDeliveryChannelsDeliveryChannel["DeliveryChannelId"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["DeliveryChannelName"].isNull())
+			deliveryChannelsObject.deliveryChannelName = valueDeliveryChannelsDeliveryChannel["DeliveryChannelName"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["DeliveryChannelType"].isNull())
+			deliveryChannelsObject.deliveryChannelType = valueDeliveryChannelsDeliveryChannel["DeliveryChannelType"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["DeliveryChannelTargetArn"].isNull())
+			deliveryChannelsObject.deliveryChannelTargetArn = valueDeliveryChannelsDeliveryChannel["DeliveryChannelTargetArn"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["DeliveryChannelAssumeRoleArn"].isNull())
+			deliveryChannelsObject.deliveryChannelAssumeRoleArn = valueDeliveryChannelsDeliveryChannel["DeliveryChannelAssumeRoleArn"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["DeliveryChannelCondition"].isNull())
+			deliveryChannelsObject.deliveryChannelCondition = valueDeliveryChannelsDeliveryChannel["DeliveryChannelCondition"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["Description"].isNull())
+			deliveryChannelsObject.description = valueDeliveryChannelsDeliveryChannel["Description"].asString();
+		if(!valueDeliveryChannelsDeliveryChannel["Status"].isNull())
+			deliveryChannelsObject.status = std::stoi(valueDeliveryChannelsDeliveryChannel["Status"].asString());
+		deliveryChannels_.push_back(deliveryChannelsObject);
+	}
+
+}
+
+std::vector<DescribeDeliveryChannelsResult::DeliveryChannel> DescribeDeliveryChannelsResult::getDeliveryChannels()const
+{
+	return deliveryChannels_;
+}
+

config/src/model/DescribeDiscoveredResourceRequest.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/DescribeDiscoveredResourceRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeDiscoveredResourceRequest;
+
+DescribeDiscoveredResourceRequest::DescribeDiscoveredResourceRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DescribeDiscoveredResource")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeDiscoveredResourceRequest::~DescribeDiscoveredResourceRequest()
+{}
+
+std::string DescribeDiscoveredResourceRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void DescribeDiscoveredResourceRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+bool DescribeDiscoveredResourceRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void DescribeDiscoveredResourceRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+std::string DescribeDiscoveredResourceRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void DescribeDiscoveredResourceRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string DescribeDiscoveredResourceRequest::getRegion()const
+{
+	return region_;
+}
+
+void DescribeDiscoveredResourceRequest::setRegion(const std::string& region)
+{
+	region_ = region;
+	setParameter("Region", region);
+}
+
+long DescribeDiscoveredResourceRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void DescribeDiscoveredResourceRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/DescribeDiscoveredResourceResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeDiscoveredResourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeDiscoveredResourceResult::DescribeDiscoveredResourceResult() :
+	ServiceResult()
+{}
+
+DescribeDiscoveredResourceResult::DescribeDiscoveredResourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDiscoveredResourceResult::~DescribeDiscoveredResourceResult()
+{}
+
+void DescribeDiscoveredResourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto discoveredResourceDetailNode = value["DiscoveredResourceDetail"];
+	if(!discoveredResourceDetailNode["AccountId"].isNull())
+		discoveredResourceDetail_.accountId = std::stol(discoveredResourceDetailNode["AccountId"].asString());
+	if(!discoveredResourceDetailNode["ResourceId"].isNull())
+		discoveredResourceDetail_.resourceId = discoveredResourceDetailNode["ResourceId"].asString();
+	if(!discoveredResourceDetailNode["ResourceType"].isNull())
+		discoveredResourceDetail_.resourceType = discoveredResourceDetailNode["ResourceType"].asString();
+	if(!discoveredResourceDetailNode["ResourceName"].isNull())
+		discoveredResourceDetail_.resourceName = discoveredResourceDetailNode["ResourceName"].asString();
+	if(!discoveredResourceDetailNode["Region"].isNull())
+		discoveredResourceDetail_.region = discoveredResourceDetailNode["Region"].asString();
+	if(!discoveredResourceDetailNode["AvailabilityZone"].isNull())
+		discoveredResourceDetail_.availabilityZone = discoveredResourceDetailNode["AvailabilityZone"].asString();
+	if(!discoveredResourceDetailNode["ResourceCreationTime"].isNull())
+		discoveredResourceDetail_.resourceCreationTime = std::stol(discoveredResourceDetailNode["ResourceCreationTime"].asString());
+	if(!discoveredResourceDetailNode["ResourceStatus"].isNull())
+		discoveredResourceDetail_.resourceStatus = discoveredResourceDetailNode["ResourceStatus"].asString();
+	if(!discoveredResourceDetailNode["ResourceDeleted"].isNull())
+		discoveredResourceDetail_.resourceDeleted = std::stoi(discoveredResourceDetailNode["ResourceDeleted"].asString());
+	if(!discoveredResourceDetailNode["Tags"].isNull())
+		discoveredResourceDetail_.tags = discoveredResourceDetailNode["Tags"].asString();
+	if(!discoveredResourceDetailNode["Configuration"].isNull())
+		discoveredResourceDetail_.configuration = discoveredResourceDetailNode["Configuration"].asString();
+
+}
+
+DescribeDiscoveredResourceResult::DiscoveredResourceDetail DescribeDiscoveredResourceResult::getDiscoveredResourceDetail()const
+{
+	return discoveredResourceDetail_;
+}
+

config/src/model/DescribeEvaluationResultsRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeEvaluationResultsRequest.h>
+
+using AlibabaCloud::Config::Model::DescribeEvaluationResultsRequest;
+
+DescribeEvaluationResultsRequest::DescribeEvaluationResultsRequest() :
+	RpcServiceRequest("config", "2019-01-08", "DescribeEvaluationResults")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeEvaluationResultsRequest::~DescribeEvaluationResultsRequest()
+{}
+
+std::string DescribeEvaluationResultsRequest::getConfigRuleId()const
+{
+	return configRuleId_;
+}
+
+void DescribeEvaluationResultsRequest::setConfigRuleId(const std::string& configRuleId)
+{
+	configRuleId_ = configRuleId;
+	setParameter("ConfigRuleId", configRuleId);
+}
+
+bool DescribeEvaluationResultsRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void DescribeEvaluationResultsRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+int DescribeEvaluationResultsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeEvaluationResultsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int DescribeEvaluationResultsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeEvaluationResultsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeEvaluationResultsRequest::getComplianceType()const
+{
+	return complianceType_;
+}
+
+void DescribeEvaluationResultsRequest::setComplianceType(const std::string& complianceType)
+{
+	complianceType_ = complianceType;
+	setParameter("ComplianceType", complianceType);
+}
+
+std::string DescribeEvaluationResultsRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void DescribeEvaluationResultsRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+std::string DescribeEvaluationResultsRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void DescribeEvaluationResultsRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+long DescribeEvaluationResultsRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void DescribeEvaluationResultsRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/DescribeEvaluationResultsResult.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/DescribeEvaluationResultsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+DescribeEvaluationResultsResult::DescribeEvaluationResultsResult() :
+	ServiceResult()
+{}
+
+DescribeEvaluationResultsResult::DescribeEvaluationResultsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeEvaluationResultsResult::~DescribeEvaluationResultsResult()
+{}
+
+void DescribeEvaluationResultsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto evaluationResultsNode = value["EvaluationResults"];
+	if(!evaluationResultsNode["PageNumber"].isNull())
+		evaluationResults_.pageNumber = std::stoi(evaluationResultsNode["PageNumber"].asString());
+	if(!evaluationResultsNode["PageSize"].isNull())
+		evaluationResults_.pageSize = std::stoi(evaluationResultsNode["PageSize"].asString());
+	if(!evaluationResultsNode["TotalCount"].isNull())
+		evaluationResults_.totalCount = std::stol(evaluationResultsNode["TotalCount"].asString());
+	auto allEvaluationResultListNode = evaluationResultsNode["EvaluationResultList"]["EvaluationResult"];
+	for (auto evaluationResultsNodeEvaluationResultListEvaluationResult : allEvaluationResultListNode)
+	{
+		EvaluationResults::EvaluationResult evaluationResultObject;
+		if(!evaluationResultsNodeEvaluationResultListEvaluationResult["Annotation"].isNull())
+			evaluationResultObject.annotation = evaluationResultsNodeEvaluationResultListEvaluationResult["Annotation"].asString();
+		if(!evaluationResultsNodeEvaluationResultListEvaluationResult["ComplianceType"].isNull())
+			evaluationResultObject.complianceType = evaluationResultsNodeEvaluationResultListEvaluationResult["ComplianceType"].asString();
+		if(!evaluationResultsNodeEvaluationResultListEvaluationResult["ConfigRuleInvokedTimestamp"].isNull())
+			evaluationResultObject.configRuleInvokedTimestamp = std::stol(evaluationResultsNodeEvaluationResultListEvaluationResult["ConfigRuleInvokedTimestamp"].asString());
+		if(!evaluationResultsNodeEvaluationResultListEvaluationResult["InvokingEventMessageType"].isNull())
+			evaluationResultObject.invokingEventMessageType = evaluationResultsNodeEvaluationResultListEvaluationResult["InvokingEventMessageType"].asString();
+		if(!evaluationResultsNodeEvaluationResultListEvaluationResult["ResultRecordedTimestamp"].isNull())
+			evaluationResultObject.resultRecordedTimestamp = std::stol(evaluationResultsNodeEvaluationResultListEvaluationResult["ResultRecordedTimestamp"].asString());
+		if(!evaluationResultsNodeEvaluationResultListEvaluationResult["RiskLevel"].isNull())
+			evaluationResultObject.riskLevel = std::stoi(evaluationResultsNodeEvaluationResultListEvaluationResult["RiskLevel"].asString());
+		auto evaluationResultIdentifierNode = value["EvaluationResultIdentifier"];
+		if(!evaluationResultIdentifierNode["OrderingTimestamp"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.orderingTimestamp = std::stol(evaluationResultIdentifierNode["OrderingTimestamp"].asString());
+		auto evaluationResultQualifierNode = evaluationResultIdentifierNode["EvaluationResultQualifier"];
+		if(!evaluationResultQualifierNode["ConfigRuleArn"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.evaluationResultQualifier.configRuleArn = evaluationResultQualifierNode["ConfigRuleArn"].asString();
+		if(!evaluationResultQualifierNode["ConfigRuleId"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.evaluationResultQualifier.configRuleId = evaluationResultQualifierNode["ConfigRuleId"].asString();
+		if(!evaluationResultQualifierNode["ConfigRuleName"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.evaluationResultQualifier.configRuleName = evaluationResultQualifierNode["ConfigRuleName"].asString();
+		if(!evaluationResultQualifierNode["ResourceId"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.evaluationResultQualifier.resourceId = evaluationResultQualifierNode["ResourceId"].asString();
+		if(!evaluationResultQualifierNode["ResourceType"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.evaluationResultQualifier.resourceType = evaluationResultQualifierNode["ResourceType"].asString();
+		if(!evaluationResultQualifierNode["RegionId"].isNull())
+			evaluationResultObject.evaluationResultIdentifier.evaluationResultQualifier.regionId = evaluationResultQualifierNode["RegionId"].asString();
+		evaluationResults_.evaluationResultList.push_back(evaluationResultObject);
+	}
+
+}
+
+DescribeEvaluationResultsResult::EvaluationResults DescribeEvaluationResultsResult::getEvaluationResults()const
+{
+	return evaluationResults_;
+}
+

config/src/model/GetDiscoveredResourceCountsRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetDiscoveredResourceCountsRequest.h>
+
+using AlibabaCloud::Config::Model::GetDiscoveredResourceCountsRequest;
+
+GetDiscoveredResourceCountsRequest::GetDiscoveredResourceCountsRequest() :
+	RpcServiceRequest("config", "2019-01-08", "GetDiscoveredResourceCounts")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetDiscoveredResourceCountsRequest::~GetDiscoveredResourceCountsRequest()
+{}
+
+bool GetDiscoveredResourceCountsRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void GetDiscoveredResourceCountsRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+std::string GetDiscoveredResourceCountsRequest::getGroupByKey()const
+{
+	return groupByKey_;
+}
+
+void GetDiscoveredResourceCountsRequest::setGroupByKey(const std::string& groupByKey)
+{
+	groupByKey_ = groupByKey;
+	setParameter("GroupByKey", groupByKey);
+}
+
+long GetDiscoveredResourceCountsRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void GetDiscoveredResourceCountsRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/GetDiscoveredResourceCountsResult.cc

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

config/src/model/GetDiscoveredResourceSummaryRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/GetDiscoveredResourceSummaryRequest.h>
+
+using AlibabaCloud::Config::Model::GetDiscoveredResourceSummaryRequest;
+
+GetDiscoveredResourceSummaryRequest::GetDiscoveredResourceSummaryRequest() :
+	RpcServiceRequest("config", "2019-01-08", "GetDiscoveredResourceSummary")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetDiscoveredResourceSummaryRequest::~GetDiscoveredResourceSummaryRequest()
+{}
+
+bool GetDiscoveredResourceSummaryRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void GetDiscoveredResourceSummaryRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+long GetDiscoveredResourceSummaryRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void GetDiscoveredResourceSummaryRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/GetDiscoveredResourceSummaryResult.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/GetDiscoveredResourceSummaryResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetDiscoveredResourceSummaryResult::GetDiscoveredResourceSummaryResult() :
+	ServiceResult()
+{}
+
+GetDiscoveredResourceSummaryResult::GetDiscoveredResourceSummaryResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDiscoveredResourceSummaryResult::~GetDiscoveredResourceSummaryResult()
+{}
+
+void GetDiscoveredResourceSummaryResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto discoveredResourceSummaryNode = value["DiscoveredResourceSummary"];
+	if(!discoveredResourceSummaryNode["ResourceCount"].isNull())
+		discoveredResourceSummary_.resourceCount = std::stoi(discoveredResourceSummaryNode["ResourceCount"].asString());
+	if(!discoveredResourceSummaryNode["ResourceTypeCount"].isNull())
+		discoveredResourceSummary_.resourceTypeCount = std::stoi(discoveredResourceSummaryNode["ResourceTypeCount"].asString());
+	if(!discoveredResourceSummaryNode["RegionCount"].isNull())
+		discoveredResourceSummary_.regionCount = std::stoi(discoveredResourceSummaryNode["RegionCount"].asString());
+
+}
+
+GetDiscoveredResourceSummaryResult::DiscoveredResourceSummary GetDiscoveredResourceSummaryResult::getDiscoveredResourceSummary()const
+{
+	return discoveredResourceSummary_;
+}
+

config/src/model/GetResourceComplianceTimelineRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/GetResourceComplianceTimelineRequest.h>
+
+using AlibabaCloud::Config::Model::GetResourceComplianceTimelineRequest;
+
+GetResourceComplianceTimelineRequest::GetResourceComplianceTimelineRequest() :
+	RpcServiceRequest("config", "2019-01-08", "GetResourceComplianceTimeline")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetResourceComplianceTimelineRequest::~GetResourceComplianceTimelineRequest()
+{}
+
+bool GetResourceComplianceTimelineRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void GetResourceComplianceTimelineRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+long GetResourceComplianceTimelineRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetResourceComplianceTimelineRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetResourceComplianceTimelineRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void GetResourceComplianceTimelineRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+int GetResourceComplianceTimelineRequest::getLimit()const
+{
+	return limit_;
+}
+
+void GetResourceComplianceTimelineRequest::setLimit(int limit)
+{
+	limit_ = limit;
+	setParameter("Limit", std::to_string(limit));
+}
+
+std::string GetResourceComplianceTimelineRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void GetResourceComplianceTimelineRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+long GetResourceComplianceTimelineRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetResourceComplianceTimelineRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+std::string GetResourceComplianceTimelineRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void GetResourceComplianceTimelineRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string GetResourceComplianceTimelineRequest::getRegion()const
+{
+	return region_;
+}
+
+void GetResourceComplianceTimelineRequest::setRegion(const std::string& region)
+{
+	region_ = region;
+	setParameter("Region", region);
+}
+
+std::string GetResourceComplianceTimelineRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void GetResourceComplianceTimelineRequest::setMemberId(const std::string& memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", memberId);
+}
+

config/src/model/GetResourceComplianceTimelineResult.cc

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/GetResourceComplianceTimelineResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetResourceComplianceTimelineResult::GetResourceComplianceTimelineResult() :
+	ServiceResult()
+{}
+
+GetResourceComplianceTimelineResult::GetResourceComplianceTimelineResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceComplianceTimelineResult::~GetResourceComplianceTimelineResult()
+{}
+
+void GetResourceComplianceTimelineResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resourceComplianceTimelineNode = value["ResourceComplianceTimeline"];
+	if(!resourceComplianceTimelineNode["Limit"].isNull())
+		resourceComplianceTimeline_.limit = std::stoi(resourceComplianceTimelineNode["Limit"].asString());
+	if(!resourceComplianceTimelineNode["TotalCount"].isNull())
+		resourceComplianceTimeline_.totalCount = std::stol(resourceComplianceTimelineNode["TotalCount"].asString());
+	if(!resourceComplianceTimelineNode["NextToken"].isNull())
+		resourceComplianceTimeline_.nextToken = resourceComplianceTimelineNode["NextToken"].asString();
+	auto allComplianceListNode = resourceComplianceTimelineNode["ComplianceList"]["ComplianceListItem"];
+	for (auto resourceComplianceTimelineNodeComplianceListComplianceListItem : allComplianceListNode)
+	{
+		ResourceComplianceTimeline::ComplianceListItem complianceListItemObject;
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["AccountId"].isNull())
+			complianceListItemObject.accountId = resourceComplianceTimelineNodeComplianceListComplianceListItem["AccountId"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["AvailabilityZone"].isNull())
+			complianceListItemObject.availabilityZone = resourceComplianceTimelineNodeComplianceListComplianceListItem["AvailabilityZone"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["CaptureTime"].isNull())
+			complianceListItemObject.captureTime = std::stol(resourceComplianceTimelineNodeComplianceListComplianceListItem["CaptureTime"].asString());
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["Configuration"].isNull())
+			complianceListItemObject.configuration = resourceComplianceTimelineNodeComplianceListComplianceListItem["Configuration"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["ConfigurationDiff"].isNull())
+			complianceListItemObject.configurationDiff = resourceComplianceTimelineNodeComplianceListComplianceListItem["ConfigurationDiff"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["Region"].isNull())
+			complianceListItemObject.region = resourceComplianceTimelineNodeComplianceListComplianceListItem["Region"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceCreateTime"].isNull())
+			complianceListItemObject.resourceCreateTime = std::stol(resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceCreateTime"].asString());
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceId"].isNull())
+			complianceListItemObject.resourceId = resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceId"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceName"].isNull())
+			complianceListItemObject.resourceName = resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceName"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceStatus"].isNull())
+			complianceListItemObject.resourceStatus = resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceStatus"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceType"].isNull())
+			complianceListItemObject.resourceType = resourceComplianceTimelineNodeComplianceListComplianceListItem["ResourceType"].asString();
+		if(!resourceComplianceTimelineNodeComplianceListComplianceListItem["Tags"].isNull())
+			complianceListItemObject.tags = resourceComplianceTimelineNodeComplianceListComplianceListItem["Tags"].asString();
+		resourceComplianceTimeline_.complianceList.push_back(complianceListItemObject);
+	}
+
+}
+
+GetResourceComplianceTimelineResult::ResourceComplianceTimeline GetResourceComplianceTimelineResult::getResourceComplianceTimeline()const
+{
+	return resourceComplianceTimeline_;
+}
+

config/src/model/GetResourceConfigurationTimelineRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/GetResourceConfigurationTimelineRequest.h>
+
+using AlibabaCloud::Config::Model::GetResourceConfigurationTimelineRequest;
+
+GetResourceConfigurationTimelineRequest::GetResourceConfigurationTimelineRequest() :
+	RpcServiceRequest("config", "2019-01-08", "GetResourceConfigurationTimeline")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetResourceConfigurationTimelineRequest::~GetResourceConfigurationTimelineRequest()
+{}
+
+bool GetResourceConfigurationTimelineRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void GetResourceConfigurationTimelineRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+long GetResourceConfigurationTimelineRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetResourceConfigurationTimelineRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetResourceConfigurationTimelineRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void GetResourceConfigurationTimelineRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+int GetResourceConfigurationTimelineRequest::getLimit()const
+{
+	return limit_;
+}
+
+void GetResourceConfigurationTimelineRequest::setLimit(int limit)
+{
+	limit_ = limit;
+	setParameter("Limit", std::to_string(limit));
+}
+
+std::string GetResourceConfigurationTimelineRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void GetResourceConfigurationTimelineRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+long GetResourceConfigurationTimelineRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetResourceConfigurationTimelineRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+std::string GetResourceConfigurationTimelineRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void GetResourceConfigurationTimelineRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string GetResourceConfigurationTimelineRequest::getRegion()const
+{
+	return region_;
+}
+
+void GetResourceConfigurationTimelineRequest::setRegion(const std::string& region)
+{
+	region_ = region;
+	setParameter("Region", region);
+}
+
+long GetResourceConfigurationTimelineRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void GetResourceConfigurationTimelineRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/GetResourceConfigurationTimelineResult.cc

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/GetResourceConfigurationTimelineResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+GetResourceConfigurationTimelineResult::GetResourceConfigurationTimelineResult() :
+	ServiceResult()
+{}
+
+GetResourceConfigurationTimelineResult::GetResourceConfigurationTimelineResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceConfigurationTimelineResult::~GetResourceConfigurationTimelineResult()
+{}
+
+void GetResourceConfigurationTimelineResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resourceConfigurationTimelineNode = value["ResourceConfigurationTimeline"];
+	if(!resourceConfigurationTimelineNode["NextToken"].isNull())
+		resourceConfigurationTimeline_.nextToken = resourceConfigurationTimelineNode["NextToken"].asString();
+	if(!resourceConfigurationTimelineNode["Limit"].isNull())
+		resourceConfigurationTimeline_.limit = std::stoi(resourceConfigurationTimelineNode["Limit"].asString());
+	if(!resourceConfigurationTimelineNode["TotalCount"].isNull())
+		resourceConfigurationTimeline_.totalCount = std::stol(resourceConfigurationTimelineNode["TotalCount"].asString());
+	auto allConfigurationListNode = resourceConfigurationTimelineNode["ConfigurationList"]["ConfigurationListItem"];
+	for (auto resourceConfigurationTimelineNodeConfigurationListConfigurationListItem : allConfigurationListNode)
+	{
+		ResourceConfigurationTimeline::ConfigurationListItem configurationListItemObject;
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["AccountId"].isNull())
+			configurationListItemObject.accountId = std::stol(resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["AccountId"].asString());
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["AvailabilityZone"].isNull())
+			configurationListItemObject.availabilityZone = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["AvailabilityZone"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["CaptureTime"].isNull())
+			configurationListItemObject.captureTime = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["CaptureTime"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ConfigurationDiff"].isNull())
+			configurationListItemObject.configurationDiff = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ConfigurationDiff"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Region"].isNull())
+			configurationListItemObject.region = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Region"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Relationship"].isNull())
+			configurationListItemObject.relationship = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Relationship"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["RelationshipDiff"].isNull())
+			configurationListItemObject.relationshipDiff = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["RelationshipDiff"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceCreateTime"].isNull())
+			configurationListItemObject.resourceCreateTime = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceCreateTime"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceId"].isNull())
+			configurationListItemObject.resourceId = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceId"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceName"].isNull())
+			configurationListItemObject.resourceName = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceName"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceType"].isNull())
+			configurationListItemObject.resourceType = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceType"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Tags"].isNull())
+			configurationListItemObject.tags = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Tags"].asString();
+		resourceConfigurationTimeline_.configurationList.push_back(configurationListItemObject);
+	}
+
+}
+
+GetResourceConfigurationTimelineResult::ResourceConfigurationTimeline GetResourceConfigurationTimelineResult::getResourceConfigurationTimeline()const
+{
+	return resourceConfigurationTimeline_;
+}
+

config/src/model/GetSupportedResourceTypesRequest.cc

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

config/src/model/GetSupportedResourceTypesResult.cc

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

config/src/model/ListConfigRulesRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/ListConfigRulesRequest.h>
+
+using AlibabaCloud::Config::Model::ListConfigRulesRequest;
+
+ListConfigRulesRequest::ListConfigRulesRequest() :
+	RpcServiceRequest("config", "2019-01-08", "ListConfigRules")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+ListConfigRulesRequest::~ListConfigRulesRequest()
+{}
+
+bool ListConfigRulesRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void ListConfigRulesRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+std::string ListConfigRulesRequest::getMessageType()const
+{
+	return messageType_;
+}
+
+void ListConfigRulesRequest::setMessageType(const std::string& messageType)
+{
+	messageType_ = messageType;
+	setParameter("MessageType", messageType);
+}
+
+std::string ListConfigRulesRequest::getConfigRuleState()const
+{
+	return configRuleState_;
+}
+
+void ListConfigRulesRequest::setConfigRuleState(const std::string& configRuleState)
+{
+	configRuleState_ = configRuleState;
+	setParameter("ConfigRuleState", configRuleState);
+}
+
+int ListConfigRulesRequest::getRiskLevel()const
+{
+	return riskLevel_;
+}
+
+void ListConfigRulesRequest::setRiskLevel(int riskLevel)
+{
+	riskLevel_ = riskLevel;
+	setParameter("RiskLevel", std::to_string(riskLevel));
+}
+
+int ListConfigRulesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListConfigRulesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListConfigRulesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListConfigRulesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListConfigRulesRequest::getComplianceType()const
+{
+	return complianceType_;
+}
+
+void ListConfigRulesRequest::setComplianceType(const std::string& complianceType)
+{
+	complianceType_ = complianceType;
+	setParameter("ComplianceType", complianceType);
+}
+
+long ListConfigRulesRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void ListConfigRulesRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/ListConfigRulesResult.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ListConfigRulesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+ListConfigRulesResult::ListConfigRulesResult() :
+	ServiceResult()
+{}
+
+ListConfigRulesResult::ListConfigRulesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListConfigRulesResult::~ListConfigRulesResult()
+{}
+
+void ListConfigRulesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configRulesNode = value["ConfigRules"];
+	if(!configRulesNode["PageNumber"].isNull())
+		configRules_.pageNumber = std::stoi(configRulesNode["PageNumber"].asString());
+	if(!configRulesNode["PageSize"].isNull())
+		configRules_.pageSize = std::stoi(configRulesNode["PageSize"].asString());
+	if(!configRulesNode["TotalCount"].isNull())
+		configRules_.totalCount = std::stol(configRulesNode["TotalCount"].asString());
+	auto allConfigRuleListNode = configRulesNode["ConfigRuleList"]["ConfigRule"];
+	for (auto configRulesNodeConfigRuleListConfigRule : allConfigRuleListNode)
+	{
+		ConfigRules::ConfigRule configRuleObject;
+		if(!configRulesNodeConfigRuleListConfigRule["AccountId"].isNull())
+			configRuleObject.accountId = std::stol(configRulesNodeConfigRuleListConfigRule["AccountId"].asString());
+		if(!configRulesNodeConfigRuleListConfigRule["ConfigRuleArn"].isNull())
+			configRuleObject.configRuleArn = configRulesNodeConfigRuleListConfigRule["ConfigRuleArn"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["ConfigRuleId"].isNull())
+			configRuleObject.configRuleId = configRulesNodeConfigRuleListConfigRule["ConfigRuleId"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["ConfigRuleName"].isNull())
+			configRuleObject.configRuleName = configRulesNodeConfigRuleListConfigRule["ConfigRuleName"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["ConfigRuleState"].isNull())
+			configRuleObject.configRuleState = configRulesNodeConfigRuleListConfigRule["ConfigRuleState"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["Description"].isNull())
+			configRuleObject.description = configRulesNodeConfigRuleListConfigRule["Description"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["RiskLevel"].isNull())
+			configRuleObject.riskLevel = std::stoi(configRulesNodeConfigRuleListConfigRule["RiskLevel"].asString());
+		if(!configRulesNodeConfigRuleListConfigRule["SourceIdentifier"].isNull())
+			configRuleObject.sourceIdentifier = configRulesNodeConfigRuleListConfigRule["SourceIdentifier"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["SourceOwner"].isNull())
+			configRuleObject.sourceOwner = configRulesNodeConfigRuleListConfigRule["SourceOwner"].asString();
+		if(!configRulesNodeConfigRuleListConfigRule["AutomationType"].isNull())
+			configRuleObject.automationType = configRulesNodeConfigRuleListConfigRule["AutomationType"].asString();
+		auto complianceNode = value["Compliance"];
+		if(!complianceNode["ComplianceType"].isNull())
+			configRuleObject.compliance.complianceType = complianceNode["ComplianceType"].asString();
+		if(!complianceNode["Count"].isNull())
+			configRuleObject.compliance.count = std::stoi(complianceNode["Count"].asString());
+		auto createByNode = value["CreateBy"];
+		if(!createByNode["CreatorId"].isNull())
+			configRuleObject.createBy.creatorId = createByNode["CreatorId"].asString();
+		if(!createByNode["CreatorName"].isNull())
+			configRuleObject.createBy.creatorName = createByNode["CreatorName"].asString();
+		if(!createByNode["CreatorType"].isNull())
+			configRuleObject.createBy.creatorType = createByNode["CreatorType"].asString();
+		if(!createByNode["ConfigRuleSceneId"].isNull())
+			configRuleObject.createBy.configRuleSceneId = createByNode["ConfigRuleSceneId"].asString();
+		if(!createByNode["ConfigRuleSceneName"].isNull())
+			configRuleObject.createBy.configRuleSceneName = createByNode["ConfigRuleSceneName"].asString();
+		configRules_.configRuleList.push_back(configRuleObject);
+	}
+
+}
+
+ListConfigRulesResult::ConfigRules ListConfigRulesResult::getConfigRules()const
+{
+	return configRules_;
+}
+

config/src/model/ListDiscoveredResourcesRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ListDiscoveredResourcesRequest.h>
+
+using AlibabaCloud::Config::Model::ListDiscoveredResourcesRequest;
+
+ListDiscoveredResourcesRequest::ListDiscoveredResourcesRequest() :
+	RpcServiceRequest("config", "2019-01-08", "ListDiscoveredResources")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+ListDiscoveredResourcesRequest::~ListDiscoveredResourcesRequest()
+{}
+
+int ListDiscoveredResourcesRequest::getResourceDeleted()const
+{
+	return resourceDeleted_;
+}
+
+void ListDiscoveredResourcesRequest::setResourceDeleted(int resourceDeleted)
+{
+	resourceDeleted_ = resourceDeleted;
+	setParameter("ResourceDeleted", std::to_string(resourceDeleted));
+}
+
+bool ListDiscoveredResourcesRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void ListDiscoveredResourcesRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+std::string ListDiscoveredResourcesRequest::getRegions()const
+{
+	return regions_;
+}
+
+void ListDiscoveredResourcesRequest::setRegions(const std::string& regions)
+{
+	regions_ = regions;
+	setParameter("Regions", regions);
+}
+
+int ListDiscoveredResourcesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListDiscoveredResourcesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+int ListDiscoveredResourcesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListDiscoveredResourcesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListDiscoveredResourcesRequest::getComplianceType()const
+{
+	return complianceType_;
+}
+
+void ListDiscoveredResourcesRequest::setComplianceType(const std::string& complianceType)
+{
+	complianceType_ = complianceType;
+	setParameter("ComplianceType", complianceType);
+}
+
+std::string ListDiscoveredResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void ListDiscoveredResourcesRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+std::string ListDiscoveredResourcesRequest::getResourceTypes()const
+{
+	return resourceTypes_;
+}
+
+void ListDiscoveredResourcesRequest::setResourceTypes(const std::string& resourceTypes)
+{
+	resourceTypes_ = resourceTypes;
+	setParameter("ResourceTypes", resourceTypes);
+}
+
+long ListDiscoveredResourcesRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void ListDiscoveredResourcesRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/ListDiscoveredResourcesResult.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/ListDiscoveredResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+ListDiscoveredResourcesResult::ListDiscoveredResourcesResult() :
+	ServiceResult()
+{}
+
+ListDiscoveredResourcesResult::ListDiscoveredResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListDiscoveredResourcesResult::~ListDiscoveredResourcesResult()
+{}
+
+void ListDiscoveredResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto discoveredResourceProfilesNode = value["DiscoveredResourceProfiles"];
+	if(!discoveredResourceProfilesNode["PageNumber"].isNull())
+		discoveredResourceProfiles_.pageNumber = std::stoi(discoveredResourceProfilesNode["PageNumber"].asString());
+	if(!discoveredResourceProfilesNode["PageSize"].isNull())
+		discoveredResourceProfiles_.pageSize = std::stoi(discoveredResourceProfilesNode["PageSize"].asString());
+	if(!discoveredResourceProfilesNode["TotalCount"].isNull())
+		discoveredResourceProfiles_.totalCount = std::stoi(discoveredResourceProfilesNode["TotalCount"].asString());
+	auto allDiscoveredResourceProfileListNode = discoveredResourceProfilesNode["DiscoveredResourceProfileList"]["DiscoveredResourceProfile"];
+	for (auto discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile : allDiscoveredResourceProfileListNode)
+	{
+		DiscoveredResourceProfiles::DiscoveredResourceProfile discoveredResourceProfileObject;
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["AccountId"].isNull())
+			discoveredResourceProfileObject.accountId = std::stol(discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["AccountId"].asString());
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["Region"].isNull())
+			discoveredResourceProfileObject.region = discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["Region"].asString();
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceCreationTime"].isNull())
+			discoveredResourceProfileObject.resourceCreationTime = std::stol(discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceCreationTime"].asString());
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceDeleted"].isNull())
+			discoveredResourceProfileObject.resourceDeleted = std::stoi(discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceDeleted"].asString());
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceId"].isNull())
+			discoveredResourceProfileObject.resourceId = discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceId"].asString();
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceName"].isNull())
+			discoveredResourceProfileObject.resourceName = discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceName"].asString();
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceStatus"].isNull())
+			discoveredResourceProfileObject.resourceStatus = discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceStatus"].asString();
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceType"].isNull())
+			discoveredResourceProfileObject.resourceType = discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["ResourceType"].asString();
+		if(!discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["Tags"].isNull())
+			discoveredResourceProfileObject.tags = discoveredResourceProfilesNodeDiscoveredResourceProfileListDiscoveredResourceProfile["Tags"].asString();
+		discoveredResourceProfiles_.discoveredResourceProfileList.push_back(discoveredResourceProfileObject);
+	}
+
+}
+
+ListDiscoveredResourcesResult::DiscoveredResourceProfiles ListDiscoveredResourcesResult::getDiscoveredResourceProfiles()const
+{
+	return discoveredResourceProfiles_;
+}
+

config/src/model/PutConfigRuleRequest.cc

@@ -0,0 +1,183 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/PutConfigRuleRequest.h>
+
+using AlibabaCloud::Config::Model::PutConfigRuleRequest;
+
+PutConfigRuleRequest::PutConfigRuleRequest() :
+	RpcServiceRequest("config", "2019-01-08", "PutConfigRule")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PutConfigRuleRequest::~PutConfigRuleRequest()
+{}
+
+std::string PutConfigRuleRequest::getConfigRuleId()const
+{
+	return configRuleId_;
+}
+
+void PutConfigRuleRequest::setConfigRuleId(const std::string& configRuleId)
+{
+	configRuleId_ = configRuleId;
+	setBodyParameter("ConfigRuleId", configRuleId);
+}
+
+bool PutConfigRuleRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void PutConfigRuleRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+std::string PutConfigRuleRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void PutConfigRuleRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setBodyParameter("ClientToken", clientToken);
+}
+
+std::string PutConfigRuleRequest::getDescription()const
+{
+	return description_;
+}
+
+void PutConfigRuleRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+std::string PutConfigRuleRequest::getSourceIdentifier()const
+{
+	return sourceIdentifier_;
+}
+
+void PutConfigRuleRequest::setSourceIdentifier(const std::string& sourceIdentifier)
+{
+	sourceIdentifier_ = sourceIdentifier;
+	setBodyParameter("SourceIdentifier", sourceIdentifier);
+}
+
+std::string PutConfigRuleRequest::getSourceMaximumExecutionFrequency()const
+{
+	return sourceMaximumExecutionFrequency_;
+}
+
+void PutConfigRuleRequest::setSourceMaximumExecutionFrequency(const std::string& sourceMaximumExecutionFrequency)
+{
+	sourceMaximumExecutionFrequency_ = sourceMaximumExecutionFrequency;
+	setBodyParameter("SourceMaximumExecutionFrequency", sourceMaximumExecutionFrequency);
+}
+
+std::string PutConfigRuleRequest::getScopeComplianceResourceTypes()const
+{
+	return scopeComplianceResourceTypes_;
+}
+
+void PutConfigRuleRequest::setScopeComplianceResourceTypes(const std::string& scopeComplianceResourceTypes)
+{
+	scopeComplianceResourceTypes_ = scopeComplianceResourceTypes;
+	setBodyParameter("ScopeComplianceResourceTypes", scopeComplianceResourceTypes);
+}
+
+std::string PutConfigRuleRequest::getSourceDetailMessageType()const
+{
+	return sourceDetailMessageType_;
+}
+
+void PutConfigRuleRequest::setSourceDetailMessageType(const std::string& sourceDetailMessageType)
+{
+	sourceDetailMessageType_ = sourceDetailMessageType;
+	setBodyParameter("SourceDetailMessageType", sourceDetailMessageType);
+}
+
+int PutConfigRuleRequest::getRiskLevel()const
+{
+	return riskLevel_;
+}
+
+void PutConfigRuleRequest::setRiskLevel(int riskLevel)
+{
+	riskLevel_ = riskLevel;
+	setBodyParameter("RiskLevel", std::to_string(riskLevel));
+}
+
+std::string PutConfigRuleRequest::getSourceOwner()const
+{
+	return sourceOwner_;
+}
+
+void PutConfigRuleRequest::setSourceOwner(const std::string& sourceOwner)
+{
+	sourceOwner_ = sourceOwner;
+	setBodyParameter("SourceOwner", sourceOwner);
+}
+
+std::string PutConfigRuleRequest::getInputParameters()const
+{
+	return inputParameters_;
+}
+
+void PutConfigRuleRequest::setInputParameters(const std::string& inputParameters)
+{
+	inputParameters_ = inputParameters;
+	setBodyParameter("InputParameters", inputParameters);
+}
+
+std::string PutConfigRuleRequest::getConfigRuleName()const
+{
+	return configRuleName_;
+}
+
+void PutConfigRuleRequest::setConfigRuleName(const std::string& configRuleName)
+{
+	configRuleName_ = configRuleName;
+	setBodyParameter("ConfigRuleName", configRuleName);
+}
+
+std::string PutConfigRuleRequest::getScopeComplianceResourceId()const
+{
+	return scopeComplianceResourceId_;
+}
+
+void PutConfigRuleRequest::setScopeComplianceResourceId(const std::string& scopeComplianceResourceId)
+{
+	scopeComplianceResourceId_ = scopeComplianceResourceId;
+	setBodyParameter("ScopeComplianceResourceId", scopeComplianceResourceId);
+}
+
+long PutConfigRuleRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void PutConfigRuleRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/PutConfigRuleResult.cc

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

config/src/model/PutConfigurationRecorderRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/PutConfigurationRecorderRequest.h>
+
+using AlibabaCloud::Config::Model::PutConfigurationRecorderRequest;
+
+PutConfigurationRecorderRequest::PutConfigurationRecorderRequest() :
+	RpcServiceRequest("config", "2019-01-08", "PutConfigurationRecorder")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PutConfigurationRecorderRequest::~PutConfigurationRecorderRequest()
+{}
+
+std::string PutConfigurationRecorderRequest::getResourceTypes()const
+{
+	return resourceTypes_;
+}
+
+void PutConfigurationRecorderRequest::setResourceTypes(const std::string& resourceTypes)
+{
+	resourceTypes_ = resourceTypes;
+	setBodyParameter("ResourceTypes", resourceTypes);
+}
+

config/src/model/PutConfigurationRecorderResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/PutConfigurationRecorderResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+PutConfigurationRecorderResult::PutConfigurationRecorderResult() :
+	ServiceResult()
+{}
+
+PutConfigurationRecorderResult::PutConfigurationRecorderResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PutConfigurationRecorderResult::~PutConfigurationRecorderResult()
+{}
+
+void PutConfigurationRecorderResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configurationRecorderNode = value["ConfigurationRecorder"];
+	if(!configurationRecorderNode["AccountId"].isNull())
+		configurationRecorder_.accountId = std::stol(configurationRecorderNode["AccountId"].asString());
+	if(!configurationRecorderNode["ConfigurationRecorderStatus"].isNull())
+		configurationRecorder_.configurationRecorderStatus = configurationRecorderNode["ConfigurationRecorderStatus"].asString();
+	if(!configurationRecorderNode["OrganizationMasterId"].isNull())
+		configurationRecorder_.organizationMasterId = std::stol(configurationRecorderNode["OrganizationMasterId"].asString());
+	if(!configurationRecorderNode["OrganizationEnableStatus"].isNull())
+		configurationRecorder_.organizationEnableStatus = configurationRecorderNode["OrganizationEnableStatus"].asString();
+		auto allResourceTypes = configurationRecorderNode["ResourceTypes"]["ResourceType"];
+		for (auto value : allResourceTypes)
+			configurationRecorder_.resourceTypes.push_back(value.asString());
+
+}
+
+PutConfigurationRecorderResult::ConfigurationRecorder PutConfigurationRecorderResult::getConfigurationRecorder()const
+{
+	return configurationRecorder_;
+}
+

config/src/model/PutDeliveryChannelRequest.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/PutDeliveryChannelRequest.h>
+
+using AlibabaCloud::Config::Model::PutDeliveryChannelRequest;
+
+PutDeliveryChannelRequest::PutDeliveryChannelRequest() :
+	RpcServiceRequest("config", "2019-01-08", "PutDeliveryChannel")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PutDeliveryChannelRequest::~PutDeliveryChannelRequest()
+{}
+
+std::string PutDeliveryChannelRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void PutDeliveryChannelRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setBodyParameter("ClientToken", clientToken);
+}
+
+std::string PutDeliveryChannelRequest::getDescription()const
+{
+	return description_;
+}
+
+void PutDeliveryChannelRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setBodyParameter("Description", description);
+}
+
+std::string PutDeliveryChannelRequest::getDeliveryChannelTargetArn()const
+{
+	return deliveryChannelTargetArn_;
+}
+
+void PutDeliveryChannelRequest::setDeliveryChannelTargetArn(const std::string& deliveryChannelTargetArn)
+{
+	deliveryChannelTargetArn_ = deliveryChannelTargetArn;
+	setBodyParameter("DeliveryChannelTargetArn", deliveryChannelTargetArn);
+}
+
+std::string PutDeliveryChannelRequest::getDeliveryChannelCondition()const
+{
+	return deliveryChannelCondition_;
+}
+
+void PutDeliveryChannelRequest::setDeliveryChannelCondition(const std::string& deliveryChannelCondition)
+{
+	deliveryChannelCondition_ = deliveryChannelCondition;
+	setBodyParameter("DeliveryChannelCondition", deliveryChannelCondition);
+}
+
+std::string PutDeliveryChannelRequest::getDeliveryChannelAssumeRoleArn()const
+{
+	return deliveryChannelAssumeRoleArn_;
+}
+
+void PutDeliveryChannelRequest::setDeliveryChannelAssumeRoleArn(const std::string& deliveryChannelAssumeRoleArn)
+{
+	deliveryChannelAssumeRoleArn_ = deliveryChannelAssumeRoleArn;
+	setBodyParameter("DeliveryChannelAssumeRoleArn", deliveryChannelAssumeRoleArn);
+}
+
+std::string PutDeliveryChannelRequest::getDeliveryChannelName()const
+{
+	return deliveryChannelName_;
+}
+
+void PutDeliveryChannelRequest::setDeliveryChannelName(const std::string& deliveryChannelName)
+{
+	deliveryChannelName_ = deliveryChannelName;
+	setBodyParameter("DeliveryChannelName", deliveryChannelName);
+}
+
+std::string PutDeliveryChannelRequest::getDeliveryChannelId()const
+{
+	return deliveryChannelId_;
+}
+
+void PutDeliveryChannelRequest::setDeliveryChannelId(const std::string& deliveryChannelId)
+{
+	deliveryChannelId_ = deliveryChannelId;
+	setBodyParameter("DeliveryChannelId", deliveryChannelId);
+}
+
+std::string PutDeliveryChannelRequest::getDeliveryChannelType()const
+{
+	return deliveryChannelType_;
+}
+
+void PutDeliveryChannelRequest::setDeliveryChannelType(const std::string& deliveryChannelType)
+{
+	deliveryChannelType_ = deliveryChannelType;
+	setBodyParameter("DeliveryChannelType", deliveryChannelType);
+}
+
+int PutDeliveryChannelRequest::getStatus()const
+{
+	return status_;
+}
+
+void PutDeliveryChannelRequest::setStatus(int status)
+{
+	status_ = status;
+	setBodyParameter("Status", std::to_string(status));
+}
+

config/src/model/PutDeliveryChannelResult.cc

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

config/src/model/PutEvaluationsRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/PutEvaluationsRequest.h>
+
+using AlibabaCloud::Config::Model::PutEvaluationsRequest;
+
+PutEvaluationsRequest::PutEvaluationsRequest() :
+	RpcServiceRequest("config", "2019-01-08", "PutEvaluations")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PutEvaluationsRequest::~PutEvaluationsRequest()
+{}
+
+std::string PutEvaluationsRequest::getEvaluations()const
+{
+	return evaluations_;
+}
+
+void PutEvaluationsRequest::setEvaluations(const std::string& evaluations)
+{
+	evaluations_ = evaluations;
+	setBodyParameter("Evaluations", evaluations);
+}
+
+std::string PutEvaluationsRequest::getResultToken()const
+{
+	return resultToken_;
+}
+
+void PutEvaluationsRequest::setResultToken(const std::string& resultToken)
+{
+	resultToken_ = resultToken;
+	setBodyParameter("ResultToken", resultToken);
+}
+

config/src/model/PutEvaluationsResult.cc

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

config/src/model/StartConfigRuleEvaluationRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/config/model/StartConfigRuleEvaluationRequest.h>
+
+using AlibabaCloud::Config::Model::StartConfigRuleEvaluationRequest;
+
+StartConfigRuleEvaluationRequest::StartConfigRuleEvaluationRequest() :
+	RpcServiceRequest("config", "2019-01-08", "StartConfigRuleEvaluation")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StartConfigRuleEvaluationRequest::~StartConfigRuleEvaluationRequest()
+{}
+
+std::string StartConfigRuleEvaluationRequest::getConfigRuleId()const
+{
+	return configRuleId_;
+}
+
+void StartConfigRuleEvaluationRequest::setConfigRuleId(const std::string& configRuleId)
+{
+	configRuleId_ = configRuleId;
+	setParameter("ConfigRuleId", configRuleId);
+}
+
+bool StartConfigRuleEvaluationRequest::getMultiAccount()const
+{
+	return multiAccount_;
+}
+
+void StartConfigRuleEvaluationRequest::setMultiAccount(bool multiAccount)
+{
+	multiAccount_ = multiAccount;
+	setParameter("MultiAccount", multiAccount ? "true" : "false");
+}
+
+long StartConfigRuleEvaluationRequest::getMemberId()const
+{
+	return memberId_;
+}
+
+void StartConfigRuleEvaluationRequest::setMemberId(long memberId)
+{
+	memberId_ = memberId;
+	setParameter("MemberId", std::to_string(memberId));
+}
+

config/src/model/StartConfigRuleEvaluationResult.cc

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

config/src/model/StartConfigurationRecorderRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/StartConfigurationRecorderRequest.h>
+
+using AlibabaCloud::Config::Model::StartConfigurationRecorderRequest;
+
+StartConfigurationRecorderRequest::StartConfigurationRecorderRequest() :
+	RpcServiceRequest("config", "2019-01-08", "StartConfigurationRecorder")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StartConfigurationRecorderRequest::~StartConfigurationRecorderRequest()
+{}
+
+bool StartConfigurationRecorderRequest::getEnterpriseEdition()const
+{
+	return enterpriseEdition_;
+}
+
+void StartConfigurationRecorderRequest::setEnterpriseEdition(bool enterpriseEdition)
+{
+	enterpriseEdition_ = enterpriseEdition;
+	setBodyParameter("EnterpriseEdition", enterpriseEdition ? "true" : "false");
+}
+

config/src/model/StartConfigurationRecorderResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/StartConfigurationRecorderResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Config;
+using namespace AlibabaCloud::Config::Model;
+
+StartConfigurationRecorderResult::StartConfigurationRecorderResult() :
+	ServiceResult()
+{}
+
+StartConfigurationRecorderResult::StartConfigurationRecorderResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+StartConfigurationRecorderResult::~StartConfigurationRecorderResult()
+{}
+
+void StartConfigurationRecorderResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configurationRecorderNode = value["ConfigurationRecorder"];
+	if(!configurationRecorderNode["AccountId"].isNull())
+		configurationRecorder_.accountId = std::stol(configurationRecorderNode["AccountId"].asString());
+	if(!configurationRecorderNode["ConfigurationRecorderStatus"].isNull())
+		configurationRecorder_.configurationRecorderStatus = configurationRecorderNode["ConfigurationRecorderStatus"].asString();
+	if(!configurationRecorderNode["OrganizationMasterId"].isNull())
+		configurationRecorder_.organizationMasterId = std::stol(configurationRecorderNode["OrganizationMasterId"].asString());
+	if(!configurationRecorderNode["OrganizationEnableStatus"].isNull())
+		configurationRecorder_.organizationEnableStatus = configurationRecorderNode["OrganizationEnableStatus"].asString();
+		auto allResourceTypes = configurationRecorderNode["ResourceTypes"]["ResourceType"];
+		for (auto value : allResourceTypes)
+			configurationRecorder_.resourceTypes.push_back(value.asString());
+
+}
+
+StartConfigurationRecorderResult::ConfigurationRecorder StartConfigurationRecorderResult::getConfigurationRecorder()const
+{
+	return configurationRecorder_;
+}
+

config/src/model/StopConfigRulesRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/StopConfigRulesRequest.h>
+
+using AlibabaCloud::Config::Model::StopConfigRulesRequest;
+
+StopConfigRulesRequest::StopConfigRulesRequest() :
+	RpcServiceRequest("config", "2019-01-08", "StopConfigRules")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+StopConfigRulesRequest::~StopConfigRulesRequest()
+{}
+
+std::string StopConfigRulesRequest::getConfigRuleIds()const
+{
+	return configRuleIds_;
+}
+
+void StopConfigRulesRequest::setConfigRuleIds(const std::string& configRuleIds)
+{
+	configRuleIds_ = configRuleIds;
+	setParameter("ConfigRuleIds", configRuleIds);
+}
+

config/src/model/StopConfigRulesResult.cc

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