Generated 2019-09-10 for waf-openapi.

CHANGELOG

@@ -1,3 +1,74 @@
+2021-12-14 Version: 1.36.979
+- Generated 2019-09-10 for `waf-openapi`.
+
+2021-12-13 Version: 1.36.978
+- CreateServerlessDBInstance Add CapacityUnit.
+
+2021-12-13 Version: 1.36.977
+- Openapi support querydisplay.
+
+2021-12-13 Version: 1.36.976
+- Support query resourceType.
+
+2021-12-13 Version: 1.36.975
+- Support query resourceType.
+
+2021-12-13 Version: 1.36.974
+- Support query resourceType.
+
+2021-12-09 Version: 1.36.973
+- Support ACR EE, OSS, EIP for deploy.
+
+2021-12-08 Version: 1.36.972
+- Add API for New Features.
+
+2021-12-08 Version: 1.36.971
+- Fixed bugs for UnbindSubscription API.
+
+2021-12-07 Version: 1.36.970
+- Fix DescribeInstances clusterId.
+
+2021-12-07 Version: 1.36.969
+- Add MetaTag APIs.
+
+2021-12-07 Version: 1.36.968
+- Add MetaTag APIs.
+
+2021-12-06 Version: 1.36.967
+- Support Bond Eni.
+
+2021-12-06 Version: 1.36.966
+- Support Bond Eni.
+
+2021-12-06 Version: 1.36.965
+- Generated 2020-05-18 for `dataworks-public`.
+
+2021-12-06 Version: 1.36.964
+- Modify the input parameter Action of DescribeCenInterRegionBandwidthLimits to be required.
+
+2021-12-03 Version: 1.36.963
+- Add EventRule Content Filter.
+- Add MetricRule Labels.
+
+2021-12-03 Version: 1.36.962
+- Support EndpointType and ServiceType.
+
+2021-12-02 Version: 1.36.961
+- Update MergeImageFace QueryFaceImageTemplate AddFaceImageTemplate DeleteFaceImageTemplate.
+
+2021-12-01 Version: 1.36.960
+- Support not switching routes when VBR health check fails.
+- Support order type when cross-account authorization and display.
+
+2021-12-01 Version: 1.36.959
+- Supported RequestDecision For YN.
+
+2021-11-30 Version: 1.36.958
+- Support health check paging.
+
+2021-11-30 Version: 1.36.957
+- Support health check paging.
+
 2021-11-29 Version: 1.36.956
 - Add API for unregister sip phone device, masked callee, etc.
 

VERSION

@@ -1 +1 @@
-1.36.956
+1.36.979

alb/CMakeLists.txt

@@ -25,10 +25,14 @@ set(alb_public_header_model
 	include/alibabacloud/alb/model/AddEntriesToAclResult.h
 	include/alibabacloud/alb/model/AddServersToServerGroupRequest.h
 	include/alibabacloud/alb/model/AddServersToServerGroupResult.h
+	include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h
+	include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.h
 	include/alibabacloud/alb/model/AssociateAclsWithListenerRequest.h
 	include/alibabacloud/alb/model/AssociateAclsWithListenerResult.h
 	include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerRequest.h
 	include/alibabacloud/alb/model/AssociateAdditionalCertificatesWithListenerResult.h
+	include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h
+	include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h
 	include/alibabacloud/alb/model/CreateAclRequest.h
 	include/alibabacloud/alb/model/CreateAclResult.h
 	include/alibabacloud/alb/model/CreateHealthCheckTemplateRequest.h
@@ -65,6 +69,8 @@ set(alb_public_header_model
 	include/alibabacloud/alb/model/DescribeRegionsResult.h
 	include/alibabacloud/alb/model/DescribeZonesRequest.h
 	include/alibabacloud/alb/model/DescribeZonesResult.h
+	include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h
+	include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.h
 	include/alibabacloud/alb/model/DisableDeletionProtectionRequest.h
 	include/alibabacloud/alb/model/DisableDeletionProtectionResult.h
 	include/alibabacloud/alb/model/DisableLoadBalancerAccessLogRequest.h
@@ -81,6 +87,8 @@ set(alb_public_header_model
 	include/alibabacloud/alb/model/GetHealthCheckTemplateAttributeResult.h
 	include/alibabacloud/alb/model/GetListenerAttributeRequest.h
 	include/alibabacloud/alb/model/GetListenerAttributeResult.h
+	include/alibabacloud/alb/model/GetListenerHealthStatusRequest.h
+	include/alibabacloud/alb/model/GetListenerHealthStatusResult.h
 	include/alibabacloud/alb/model/GetLoadBalancerAttributeRequest.h
 	include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h
 	include/alibabacloud/alb/model/ListAclEntriesRequest.h
@@ -145,6 +153,8 @@ set(alb_public_header_model
 	include/alibabacloud/alb/model/UpdateLoadBalancerAttributeResult.h
 	include/alibabacloud/alb/model/UpdateLoadBalancerEditionRequest.h
 	include/alibabacloud/alb/model/UpdateLoadBalancerEditionResult.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h
+	include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h
 	include/alibabacloud/alb/model/UpdateRuleAttributeRequest.h
 	include/alibabacloud/alb/model/UpdateRuleAttributeResult.h
 	include/alibabacloud/alb/model/UpdateRulesAttributeRequest.h
@@ -162,10 +172,14 @@ set(alb_src
 	src/model/AddEntriesToAclResult.cc
 	src/model/AddServersToServerGroupRequest.cc
 	src/model/AddServersToServerGroupResult.cc
+	src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc
+	src/model/ApplyHealthCheckTemplateToServerGroupResult.cc
 	src/model/AssociateAclsWithListenerRequest.cc
 	src/model/AssociateAclsWithListenerResult.cc
 	src/model/AssociateAdditionalCertificatesWithListenerRequest.cc
 	src/model/AssociateAdditionalCertificatesWithListenerResult.cc
+	src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.cc
+	src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc
 	src/model/CreateAclRequest.cc
 	src/model/CreateAclResult.cc
 	src/model/CreateHealthCheckTemplateRequest.cc
@@ -202,6 +216,8 @@ set(alb_src
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeZonesRequest.cc
 	src/model/DescribeZonesResult.cc
+	src/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.cc
+	src/model/DetachCommonBandwidthPackageFromLoadBalancerResult.cc
 	src/model/DisableDeletionProtectionRequest.cc
 	src/model/DisableDeletionProtectionResult.cc
 	src/model/DisableLoadBalancerAccessLogRequest.cc
@@ -218,6 +234,8 @@ set(alb_src
 	src/model/GetHealthCheckTemplateAttributeResult.cc
 	src/model/GetListenerAttributeRequest.cc
 	src/model/GetListenerAttributeResult.cc
+	src/model/GetListenerHealthStatusRequest.cc
+	src/model/GetListenerHealthStatusResult.cc
 	src/model/GetLoadBalancerAttributeRequest.cc
 	src/model/GetLoadBalancerAttributeResult.cc
 	src/model/ListAclEntriesRequest.cc
@@ -282,6 +300,8 @@ set(alb_src
 	src/model/UpdateLoadBalancerAttributeResult.cc
 	src/model/UpdateLoadBalancerEditionRequest.cc
 	src/model/UpdateLoadBalancerEditionResult.cc
+	src/model/UpdateLoadBalancerZonesRequest.cc
+	src/model/UpdateLoadBalancerZonesResult.cc
 	src/model/UpdateRuleAttributeRequest.cc
 	src/model/UpdateRuleAttributeResult.cc
 	src/model/UpdateRulesAttributeRequest.cc

alb/include/alibabacloud/alb/AlbClient.h

@@ -26,10 +26,14 @@
 #include "model/AddEntriesToAclResult.h"
 #include "model/AddServersToServerGroupRequest.h"
 #include "model/AddServersToServerGroupResult.h"
+#include "model/ApplyHealthCheckTemplateToServerGroupRequest.h"
+#include "model/ApplyHealthCheckTemplateToServerGroupResult.h"
 #include "model/AssociateAclsWithListenerRequest.h"
 #include "model/AssociateAclsWithListenerResult.h"
 #include "model/AssociateAdditionalCertificatesWithListenerRequest.h"
 #include "model/AssociateAdditionalCertificatesWithListenerResult.h"
+#include "model/AttachCommonBandwidthPackageToLoadBalancerRequest.h"
+#include "model/AttachCommonBandwidthPackageToLoadBalancerResult.h"
 #include "model/CreateAclRequest.h"
 #include "model/CreateAclResult.h"
 #include "model/CreateHealthCheckTemplateRequest.h"
@@ -66,6 +70,8 @@
 #include "model/DescribeRegionsResult.h"
 #include "model/DescribeZonesRequest.h"
 #include "model/DescribeZonesResult.h"
+#include "model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h"
+#include "model/DetachCommonBandwidthPackageFromLoadBalancerResult.h"
 #include "model/DisableDeletionProtectionRequest.h"
 #include "model/DisableDeletionProtectionResult.h"
 #include "model/DisableLoadBalancerAccessLogRequest.h"
@@ -82,6 +88,8 @@
 #include "model/GetHealthCheckTemplateAttributeResult.h"
 #include "model/GetListenerAttributeRequest.h"
 #include "model/GetListenerAttributeResult.h"
+#include "model/GetListenerHealthStatusRequest.h"
+#include "model/GetListenerHealthStatusResult.h"
 #include "model/GetLoadBalancerAttributeRequest.h"
 #include "model/GetLoadBalancerAttributeResult.h"
 #include "model/ListAclEntriesRequest.h"
@@ -146,6 +154,8 @@
 #include "model/UpdateLoadBalancerAttributeResult.h"
 #include "model/UpdateLoadBalancerEditionRequest.h"
 #include "model/UpdateLoadBalancerEditionResult.h"
+#include "model/UpdateLoadBalancerZonesRequest.h"
+#include "model/UpdateLoadBalancerZonesResult.h"
 #include "model/UpdateRuleAttributeRequest.h"
 #include "model/UpdateRuleAttributeResult.h"
 #include "model/UpdateRulesAttributeRequest.h"
@@ -171,12 +181,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AddServersToServerGroupResult> AddServersToServerGroupOutcome;
 			typedef std::future<AddServersToServerGroupOutcome> AddServersToServerGroupOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::AddServersToServerGroupRequest&, const AddServersToServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddServersToServerGroupAsyncHandler;
+			typedef Outcome<Error, Model::ApplyHealthCheckTemplateToServerGroupResult> ApplyHealthCheckTemplateToServerGroupOutcome;
+			typedef std::future<ApplyHealthCheckTemplateToServerGroupOutcome> ApplyHealthCheckTemplateToServerGroupOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::ApplyHealthCheckTemplateToServerGroupRequest&, const ApplyHealthCheckTemplateToServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyHealthCheckTemplateToServerGroupAsyncHandler;
 			typedef Outcome<Error, Model::AssociateAclsWithListenerResult> AssociateAclsWithListenerOutcome;
 			typedef std::future<AssociateAclsWithListenerOutcome> AssociateAclsWithListenerOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::AssociateAclsWithListenerRequest&, const AssociateAclsWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAclsWithListenerAsyncHandler;
 			typedef Outcome<Error, Model::AssociateAdditionalCertificatesWithListenerResult> AssociateAdditionalCertificatesWithListenerOutcome;
 			typedef std::future<AssociateAdditionalCertificatesWithListenerOutcome> AssociateAdditionalCertificatesWithListenerOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::AssociateAdditionalCertificatesWithListenerRequest&, const AssociateAdditionalCertificatesWithListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateAdditionalCertificatesWithListenerAsyncHandler;
+			typedef Outcome<Error, Model::AttachCommonBandwidthPackageToLoadBalancerResult> AttachCommonBandwidthPackageToLoadBalancerOutcome;
+			typedef std::future<AttachCommonBandwidthPackageToLoadBalancerOutcome> AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::AttachCommonBandwidthPackageToLoadBalancerRequest&, const AttachCommonBandwidthPackageToLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachCommonBandwidthPackageToLoadBalancerAsyncHandler;
 			typedef Outcome<Error, Model::CreateAclResult> CreateAclOutcome;
 			typedef std::future<CreateAclOutcome> CreateAclOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::CreateAclRequest&, const CreateAclOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAclAsyncHandler;
@@ -231,6 +247,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
 			typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
+			typedef Outcome<Error, Model::DetachCommonBandwidthPackageFromLoadBalancerResult> DetachCommonBandwidthPackageFromLoadBalancerOutcome;
+			typedef std::future<DetachCommonBandwidthPackageFromLoadBalancerOutcome> DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest&, const DetachCommonBandwidthPackageFromLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler;
 			typedef Outcome<Error, Model::DisableDeletionProtectionResult> DisableDeletionProtectionOutcome;
 			typedef std::future<DisableDeletionProtectionOutcome> DisableDeletionProtectionOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::DisableDeletionProtectionRequest&, const DisableDeletionProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDeletionProtectionAsyncHandler;
@@ -255,6 +274,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetListenerAttributeResult> GetListenerAttributeOutcome;
 			typedef std::future<GetListenerAttributeOutcome> GetListenerAttributeOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::GetListenerAttributeRequest&, const GetListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerAttributeAsyncHandler;
+			typedef Outcome<Error, Model::GetListenerHealthStatusResult> GetListenerHealthStatusOutcome;
+			typedef std::future<GetListenerHealthStatusOutcome> GetListenerHealthStatusOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::GetListenerHealthStatusRequest&, const GetListenerHealthStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetListenerHealthStatusAsyncHandler;
 			typedef Outcome<Error, Model::GetLoadBalancerAttributeResult> GetLoadBalancerAttributeOutcome;
 			typedef std::future<GetLoadBalancerAttributeOutcome> GetLoadBalancerAttributeOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::GetLoadBalancerAttributeRequest&, const GetLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLoadBalancerAttributeAsyncHandler;
@@ -351,6 +373,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateLoadBalancerEditionResult> UpdateLoadBalancerEditionOutcome;
 			typedef std::future<UpdateLoadBalancerEditionOutcome> UpdateLoadBalancerEditionOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerEditionRequest&, const UpdateLoadBalancerEditionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerEditionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLoadBalancerZonesResult> UpdateLoadBalancerZonesOutcome;
+			typedef std::future<UpdateLoadBalancerZonesOutcome> UpdateLoadBalancerZonesOutcomeCallable;
+			typedef std::function<void(const AlbClient*, const Model::UpdateLoadBalancerZonesRequest&, const UpdateLoadBalancerZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLoadBalancerZonesAsyncHandler;
 			typedef Outcome<Error, Model::UpdateRuleAttributeResult> UpdateRuleAttributeOutcome;
 			typedef std::future<UpdateRuleAttributeOutcome> UpdateRuleAttributeOutcomeCallable;
 			typedef std::function<void(const AlbClient*, const Model::UpdateRuleAttributeRequest&, const UpdateRuleAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRuleAttributeAsyncHandler;
@@ -377,12 +402,18 @@ namespace AlibabaCloud
 			AddServersToServerGroupOutcome addServersToServerGroup(const Model::AddServersToServerGroupRequest &request)const;
 			void addServersToServerGroupAsync(const Model::AddServersToServerGroupRequest& request, const AddServersToServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddServersToServerGroupOutcomeCallable addServersToServerGroupCallable(const Model::AddServersToServerGroupRequest& request) const;
+			ApplyHealthCheckTemplateToServerGroupOutcome applyHealthCheckTemplateToServerGroup(const Model::ApplyHealthCheckTemplateToServerGroupRequest &request)const;
+			void applyHealthCheckTemplateToServerGroupAsync(const Model::ApplyHealthCheckTemplateToServerGroupRequest& request, const ApplyHealthCheckTemplateToServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ApplyHealthCheckTemplateToServerGroupOutcomeCallable applyHealthCheckTemplateToServerGroupCallable(const Model::ApplyHealthCheckTemplateToServerGroupRequest& request) const;
 			AssociateAclsWithListenerOutcome associateAclsWithListener(const Model::AssociateAclsWithListenerRequest &request)const;
 			void associateAclsWithListenerAsync(const Model::AssociateAclsWithListenerRequest& request, const AssociateAclsWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AssociateAclsWithListenerOutcomeCallable associateAclsWithListenerCallable(const Model::AssociateAclsWithListenerRequest& request) const;
 			AssociateAdditionalCertificatesWithListenerOutcome associateAdditionalCertificatesWithListener(const Model::AssociateAdditionalCertificatesWithListenerRequest &request)const;
 			void associateAdditionalCertificatesWithListenerAsync(const Model::AssociateAdditionalCertificatesWithListenerRequest& request, const AssociateAdditionalCertificatesWithListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AssociateAdditionalCertificatesWithListenerOutcomeCallable associateAdditionalCertificatesWithListenerCallable(const Model::AssociateAdditionalCertificatesWithListenerRequest& request) const;
+			AttachCommonBandwidthPackageToLoadBalancerOutcome attachCommonBandwidthPackageToLoadBalancer(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest &request)const;
+			void attachCommonBandwidthPackageToLoadBalancerAsync(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest& request, const AttachCommonBandwidthPackageToLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable attachCommonBandwidthPackageToLoadBalancerCallable(const Model::AttachCommonBandwidthPackageToLoadBalancerRequest& request) const;
 			CreateAclOutcome createAcl(const Model::CreateAclRequest &request)const;
 			void createAclAsync(const Model::CreateAclRequest& request, const CreateAclAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAclOutcomeCallable createAclCallable(const Model::CreateAclRequest& request) const;
@@ -437,6 +468,9 @@ namespace AlibabaCloud
 			DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
 			void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
+			DetachCommonBandwidthPackageFromLoadBalancerOutcome detachCommonBandwidthPackageFromLoadBalancer(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest &request)const;
+			void detachCommonBandwidthPackageFromLoadBalancerAsync(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest& request, const DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable detachCommonBandwidthPackageFromLoadBalancerCallable(const Model::DetachCommonBandwidthPackageFromLoadBalancerRequest& request) const;
 			DisableDeletionProtectionOutcome disableDeletionProtection(const Model::DisableDeletionProtectionRequest &request)const;
 			void disableDeletionProtectionAsync(const Model::DisableDeletionProtectionRequest& request, const DisableDeletionProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DisableDeletionProtectionOutcomeCallable disableDeletionProtectionCallable(const Model::DisableDeletionProtectionRequest& request) const;
@@ -461,6 +495,9 @@ namespace AlibabaCloud
 			GetListenerAttributeOutcome getListenerAttribute(const Model::GetListenerAttributeRequest &request)const;
 			void getListenerAttributeAsync(const Model::GetListenerAttributeRequest& request, const GetListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetListenerAttributeOutcomeCallable getListenerAttributeCallable(const Model::GetListenerAttributeRequest& request) const;
+			GetListenerHealthStatusOutcome getListenerHealthStatus(const Model::GetListenerHealthStatusRequest &request)const;
+			void getListenerHealthStatusAsync(const Model::GetListenerHealthStatusRequest& request, const GetListenerHealthStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetListenerHealthStatusOutcomeCallable getListenerHealthStatusCallable(const Model::GetListenerHealthStatusRequest& request) const;
 			GetLoadBalancerAttributeOutcome getLoadBalancerAttribute(const Model::GetLoadBalancerAttributeRequest &request)const;
 			void getLoadBalancerAttributeAsync(const Model::GetLoadBalancerAttributeRequest& request, const GetLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetLoadBalancerAttributeOutcomeCallable getLoadBalancerAttributeCallable(const Model::GetLoadBalancerAttributeRequest& request) const;
@@ -557,6 +594,9 @@ namespace AlibabaCloud
 			UpdateLoadBalancerEditionOutcome updateLoadBalancerEdition(const Model::UpdateLoadBalancerEditionRequest &request)const;
 			void updateLoadBalancerEditionAsync(const Model::UpdateLoadBalancerEditionRequest& request, const UpdateLoadBalancerEditionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateLoadBalancerEditionOutcomeCallable updateLoadBalancerEditionCallable(const Model::UpdateLoadBalancerEditionRequest& request) const;
+			UpdateLoadBalancerZonesOutcome updateLoadBalancerZones(const Model::UpdateLoadBalancerZonesRequest &request)const;
+			void updateLoadBalancerZonesAsync(const Model::UpdateLoadBalancerZonesRequest& request, const UpdateLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLoadBalancerZonesOutcomeCallable updateLoadBalancerZonesCallable(const Model::UpdateLoadBalancerZonesRequest& request) const;
 			UpdateRuleAttributeOutcome updateRuleAttribute(const Model::UpdateRuleAttributeRequest &request)const;
 			void updateRuleAttributeAsync(const Model::UpdateRuleAttributeRequest& request, const UpdateRuleAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateRuleAttributeOutcomeCallable updateRuleAttributeCallable(const Model::UpdateRuleAttributeRequest& request) const;

alb/include/alibabacloud/alb/model/AddServersToServerGroupRequest.h

@@ -29,6 +29,7 @@ namespace Model {
 class ALIBABACLOUD_ALB_EXPORT AddServersToServerGroupRequest : public RpcServiceRequest {
 public:
 	struct Servers {
+		bool remoteIpEnabled;
 		std::string serverType;
 		int port;
 		std::string description;

alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.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_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT ApplyHealthCheckTemplateToServerGroupRequest : public RpcServiceRequest {
+public:
+	ApplyHealthCheckTemplateToServerGroupRequest();
+	~ApplyHealthCheckTemplateToServerGroupRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getServerGroupId() const;
+	void setServerGroupId(const std::string &serverGroupId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getHealthCheckTemplateId() const;
+	void setHealthCheckTemplateId(const std::string &healthCheckTemplateId);
+
+private:
+	std::string clientToken_;
+	std::string serverGroupId_;
+	bool dryRun_;
+	std::string healthCheckTemplateId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPREQUEST_H_

alb/include/alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupResult.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_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT ApplyHealthCheckTemplateToServerGroupResult : public ServiceResult
+			{
+			public:
+
+
+				ApplyHealthCheckTemplateToServerGroupResult();
+				explicit ApplyHealthCheckTemplateToServerGroupResult(const std::string &payload);
+				~ApplyHealthCheckTemplateToServerGroupResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_APPLYHEALTHCHECKTEMPLATETOSERVERGROUPRESULT_H_

alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.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_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT AttachCommonBandwidthPackageToLoadBalancerRequest : public RpcServiceRequest {
+public:
+	AttachCommonBandwidthPackageToLoadBalancerRequest();
+	~AttachCommonBandwidthPackageToLoadBalancerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getBandwidthPackageId() const;
+	void setBandwidthPackageId(const std::string &bandwidthPackageId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::string bandwidthPackageId_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERREQUEST_H_

alb/include/alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.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_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT AttachCommonBandwidthPackageToLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				AttachCommonBandwidthPackageToLoadBalancerResult();
+				explicit AttachCommonBandwidthPackageToLoadBalancerResult(const std::string &payload);
+				~AttachCommonBandwidthPackageToLoadBalancerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_ATTACHCOMMONBANDWIDTHPACKAGETOLOADBALANCERRESULT_H_

alb/include/alibabacloud/alb/model/CreateLoadBalancerRequest.h

@@ -33,6 +33,7 @@ public:
 		std::string status;
 	};
 	struct LoadBalancerBillingConfig {
+		std::string bandwidthPackageId;
 		std::string internetChargeType;
 		int internetBandwidth;
 		std::string payType;
@@ -40,6 +41,7 @@ public:
 	struct ZoneMappings {
 		std::string vSwitchId;
 		std::string zoneId;
+		std::string allocationId;
 	};
 	CreateLoadBalancerRequest();
 	~CreateLoadBalancerRequest();
@@ -51,6 +53,8 @@ public:
 	void setModificationProtectionConfig(const ModificationProtectionConfig &modificationProtectionConfig);
 	LoadBalancerBillingConfig getLoadBalancerBillingConfig() const;
 	void setLoadBalancerBillingConfig(const LoadBalancerBillingConfig &loadBalancerBillingConfig);
+	std::string getAddressIpVersion() const;
+	void setAddressIpVersion(const std::string &addressIpVersion);
 	bool getDeletionProtectionEnabled() const;
 	void setDeletionProtectionEnabled(bool deletionProtectionEnabled);
 	std::string getResourceGroupId() const;
@@ -73,6 +77,7 @@ private:
 	std::string clientToken_;
 	ModificationProtectionConfig modificationProtectionConfig_;
 	LoadBalancerBillingConfig loadBalancerBillingConfig_;
+	std::string addressIpVersion_;
 	bool deletionProtectionEnabled_;
 	std::string resourceGroupId_;
 	std::string loadBalancerName_;

alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h

@@ -66,10 +66,14 @@ public:
 	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getProtocol() const;
 	void setProtocol(const std::string &protocol);
+	bool getUpstreamKeepaliveEnabled() const;
+	void setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled);
 	StickySessionConfig getStickySessionConfig() const;
 	void setStickySessionConfig(const StickySessionConfig &stickySessionConfig);
 	bool getDryRun() const;
 	void setDryRun(bool dryRun);
+	bool getIpv6Enabled() const;
+	void setIpv6Enabled(bool ipv6Enabled);
 	std::string getServerGroupType() const;
 	void setServerGroupType(const std::string &serverGroupType);
 	std::string getVpcId() const;
@@ -82,8 +86,10 @@ private:
 	std::string scheduler_;
 	std::string resourceGroupId_;
 	std::string protocol_;
+	bool upstreamKeepaliveEnabled_;
 	StickySessionConfig stickySessionConfig_;
 	bool dryRun_;
+	bool ipv6Enabled_;
 	std::string serverGroupType_;
 	std::string vpcId_;
 };

alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.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_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT DetachCommonBandwidthPackageFromLoadBalancerRequest : public RpcServiceRequest {
+public:
+	DetachCommonBandwidthPackageFromLoadBalancerRequest();
+	~DetachCommonBandwidthPackageFromLoadBalancerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getBandwidthPackageId() const;
+	void setBandwidthPackageId(const std::string &bandwidthPackageId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::string bandwidthPackageId_;
+	bool dryRun_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERREQUEST_H_

alb/include/alibabacloud/alb/model/DetachCommonBandwidthPackageFromLoadBalancerResult.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_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT DetachCommonBandwidthPackageFromLoadBalancerResult : public ServiceResult
+			{
+			public:
+
+
+				DetachCommonBandwidthPackageFromLoadBalancerResult();
+				explicit DetachCommonBandwidthPackageFromLoadBalancerResult(const std::string &payload);
+				~DetachCommonBandwidthPackageFromLoadBalancerResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_DETACHCOMMONBANDWIDTHPACKAGEFROMLOADBALANCERRESULT_H_

alb/include/alibabacloud/alb/model/GetListenerHealthStatusRequest.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_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT GetListenerHealthStatusRequest : public RpcServiceRequest {
+public:
+	GetListenerHealthStatusRequest();
+	~GetListenerHealthStatusRequest();
+	bool getIncludeRule() const;
+	void setIncludeRule(bool includeRule);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	long getMaxResults() const;
+	void setMaxResults(long maxResults);
+
+private:
+	bool includeRule_;
+	std::string listenerId_;
+	std::string nextToken_;
+	long maxResults_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSREQUEST_H_

alb/include/alibabacloud/alb/model/GetListenerHealthStatusResult.h

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alb/AlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALB_EXPORT GetListenerHealthStatusResult : public ServiceResult
+			{
+			public:
+				struct ListenerHealthStatusModel
+				{
+					struct ServerGroupHealthStatusModel
+					{
+						struct BackendServerHealthStatusModel
+						{
+							struct Reason
+							{
+								std::string expectedResponse;
+								std::string actualResponse;
+								std::string reasonCode;
+							};
+							std::string status;
+							std::string serverId;
+							int port;
+							std::string serverIp;
+							Reason reason;
+						};
+						std::string actionType;
+						std::vector<ServerGroupHealthStatusModel::BackendServerHealthStatusModel> nonNormalServers;
+						std::string serverGroupId;
+						std::string healthCheckEnabled;
+					};
+					int listenerPort;
+					std::vector<ListenerHealthStatusModel::ServerGroupHealthStatusModel> serverGroupInfos;
+					std::string listenerProtocol;
+					std::string listenerId;
+				};
+				struct RuleHealthStatusModel
+				{
+					struct ServerGroupHealthStatusModel2
+					{
+						struct NonNormalServer
+						{
+							struct Reason4
+							{
+								std::string expectedResponse;
+								std::string actualResponse;
+								std::string reasonCode;
+							};
+							std::string status;
+							std::string serverId;
+							Reason4 reason4;
+							int port;
+							std::string serverIp;
+						};
+						std::string actionType;
+						std::string serverGroupId;
+						std::string healthCheckEnabled;
+						std::vector<ServerGroupHealthStatusModel2::NonNormalServer> nonNormalServers3;
+					};
+					std::vector<RuleHealthStatusModel::ServerGroupHealthStatusModel2> serverGroupInfos1;
+					std::string ruleId;
+				};
+
+
+				GetListenerHealthStatusResult();
+				explicit GetListenerHealthStatusResult(const std::string &payload);
+				~GetListenerHealthStatusResult();
+				std::vector<RuleHealthStatusModel> getRuleHealthStatus()const;
+				std::vector<ListenerHealthStatusModel> getListenerHealthStatus()const;
+				std::string getNextToken()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<RuleHealthStatusModel> ruleHealthStatus_;
+				std::vector<ListenerHealthStatusModel> listenerHealthStatus_;
+				std::string nextToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALB_MODEL_GETLISTENERHEALTHSTATUSRESULT_H_

alb/include/alibabacloud/alb/model/GetLoadBalancerAttributeResult.h

@@ -68,6 +68,7 @@ namespace AlibabaCloud
 					struct LoadBalancerAddress
 					{
 						std::string address;
+						std::string ipv6Address;
 					};
 					std::string zoneId;
 					std::string vSwitchId;
@@ -79,56 +80,62 @@ namespace AlibabaCloud
 				explicit GetLoadBalancerAttributeResult(const std::string &payload);
 				~GetLoadBalancerAttributeResult();
 				bool getServiceManagedEnabled()const;
-				std::string getLoadBalancerEdition()const;
+				std::string getAddressIpVersion()const;
 				std::string getResourceGroupId()const;
-				LoadBalancerBillingConfig getLoadBalancerBillingConfig()const;
 				std::vector<std::string> getFeatureLabels()const;
-				std::string getCreateTime()const;
 				std::string getLoadBalancerId()const;
 				std::vector<ZoneMapping> getZoneMappings()const;
 				std::string getDNSName()const;
+				std::string getIpv6AddressType()const;
+				int getBandwidthCapacity()const;
+				DeletionProtectionConfig getDeletionProtectionConfig()const;
+				std::string getServiceManagedMode()const;
+				std::string getBandwidthPackageId()const;
+				std::vector<Tag> getTags()const;
+				std::string getLoadBalancerEdition()const;
+				LoadBalancerBillingConfig getLoadBalancerBillingConfig()const;
+				std::string getCreateTime()const;
 				ModificationProtectionConfig getModificationProtectionConfig()const;
 				std::string getLoadBalancerName()const;
 				AccessLogConfig getAccessLogConfig()const;
-				int getBandwidthCapacity()const;
-				DeletionProtectionConfig getDeletionProtectionConfig()const;
+				bool getConfigManagedEnabled()const;
 				std::string getLoadBalancerBussinessStatus()const;
 				std::string getVpcId()const;
-				std::string getServiceManagedMode()const;
-				std::string getBandwidthPackageId()const;
 				std::string getRegionId()const;
 				std::string getAddressAllocatedMode()const;
 				std::string getAddressType()const;
 				std::string getLoadBalancerStatus()const;
-				std::vector<Tag> getTags()const;
 				std::vector<LoadBalancerOperationLock> getLoadBalancerOperationLocks()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				bool serviceManagedEnabled_;
-				std::string loadBalancerEdition_;
+				std::string addressIpVersion_;
 				std::string resourceGroupId_;
-				LoadBalancerBillingConfig loadBalancerBillingConfig_;
 				std::vector<std::string> featureLabels_;
-				std::string createTime_;
 				std::string loadBalancerId_;
 				std::vector<ZoneMapping> zoneMappings_;
 				std::string dNSName_;
+				std::string ipv6AddressType_;
+				int bandwidthCapacity_;
+				DeletionProtectionConfig deletionProtectionConfig_;
+				std::string serviceManagedMode_;
+				std::string bandwidthPackageId_;
+				std::vector<Tag> tags_;
+				std::string loadBalancerEdition_;
+				LoadBalancerBillingConfig loadBalancerBillingConfig_;
+				std::string createTime_;
 				ModificationProtectionConfig modificationProtectionConfig_;
 				std::string loadBalancerName_;
 				AccessLogConfig accessLogConfig_;
-				int bandwidthCapacity_;
-				DeletionProtectionConfig deletionProtectionConfig_;
+				bool configManagedEnabled_;
 				std::string loadBalancerBussinessStatus_;
 				std::string vpcId_;
-				std::string serviceManagedMode_;
-				std::string bandwidthPackageId_;
 				std::string regionId_;
 				std::string addressAllocatedMode_;
 				std::string addressType_;
 				std::string loadBalancerStatus_;
-				std::vector<Tag> tags_;
 				std::vector<LoadBalancerOperationLock> loadBalancerOperationLocks_;
 
 			};

alb/include/alibabacloud/alb/model/ListAclsResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct Acl
 				{
 					bool serviceManagedEnabled;
+					bool configManagedEnabled;
 					std::string aclStatus;
 					std::string resourceGroupId;
 					std::string aclId;

alb/include/alibabacloud/alb/model/ListLoadBalancersRequest.h

@@ -38,6 +38,8 @@ public:
 	void setLoadBalancerNames(const std::vector<std::string> &loadBalancerNames);
 	std::vector<std::string> getLoadBalancerIds() const;
 	void setLoadBalancerIds(const std::vector<std::string> &loadBalancerIds);
+	std::string getAddressIpVersion() const;
+	void setAddressIpVersion(const std::string &addressIpVersion);
 	std::string getResourceGroupId() const;
 	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getNextToken() const;
@@ -60,12 +62,15 @@ public:
 	void setMaxResults(int maxResults);
 	std::string getZoneId() const;
 	void setZoneId(const std::string &zoneId);
+	std::string getIpv6AddressType() const;
+	void setIpv6AddressType(const std::string &ipv6AddressType);
 	std::string getPayType() const;
 	void setPayType(const std::string &payType);
 
 private:
 	std::vector<std::string> loadBalancerNames_;
 	std::vector<std::string> loadBalancerIds_;
+	std::string addressIpVersion_;
 	std::string resourceGroupId_;
 	std::string nextToken_;
 	std::string loadBalancerBussinessStatus_;
@@ -77,6 +82,7 @@ private:
 	std::string internetChargeType_;
 	int maxResults_;
 	std::string zoneId_;
+	std::string ipv6AddressType_;
 	std::string payType_;
 };
 } // namespace Model

alb/include/alibabacloud/alb/model/ListLoadBalancersResult.h

@@ -67,15 +67,18 @@ namespace AlibabaCloud
 					};
 					bool serviceManagedEnabled;
 					std::string loadBalancerEdition;
+					std::string addressIpVersion;
 					std::string resourceGroupId;
 					LoadBalancerBillingConfig loadBalancerBillingConfig;
 					std::string createTime;
 					std::string loadBalancerId;
 					std::string dNSName;
 					ModificationProtectionConfig modificationProtectionConfig;
+					std::string ipv6AddressType;
 					std::string loadBalancerName;
 					AccessLogConfig accessLogConfig;
 					int bandwidthCapacity;
+					bool configManagedEnabled;
 					DeletionProtectionConfig deletionProtectionConfig;
 					std::string loadBalancerBussinessStatus;
 					std::string vpcId;

alb/include/alibabacloud/alb/model/ListServerGroupServersResult.h

@@ -40,6 +40,7 @@ namespace AlibabaCloud
 					std::string serverId;
 					int port;
 					std::string serverIp;
+					bool remoteIpEnabled;
 					std::string serverGroupId;
 					int weight;
 				};

alb/include/alibabacloud/alb/model/ListServerGroupsResult.h

@@ -67,10 +67,14 @@ namespace AlibabaCloud
 					std::vector<std::string> relatedLoadBalancerIds;
 					std::string resourceGroupId;
 					std::string scheduler;
+					bool upstreamKeepaliveEnabled;
 					StickySessionConfig stickySessionConfig;
 					std::string serverGroupId;
+					int serverCount;
 					std::string serverGroupType;
 					std::string serverGroupStatus;
+					bool ipv6Enabled;
+					bool configManagedEnabled;
 					std::string vpcId;
 					std::string serviceManagedMode;
 					HealthCheckConfig healthCheckConfig;

alb/include/alibabacloud/alb/model/ReplaceServersInServerGroupRequest.h

@@ -29,6 +29,7 @@ namespace Model {
 class ALIBABACLOUD_ALB_EXPORT ReplaceServersInServerGroupRequest : public RpcServiceRequest {
 public:
 	struct AddedServers {
+		bool remoteIpEnabled;
 		std::string serverType;
 		int port;
 		std::string description;

alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_
+#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_
+
+#include <alibabacloud/alb/AlbExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Alb {
+namespace Model {
+class ALIBABACLOUD_ALB_EXPORT UpdateLoadBalancerZonesRequest : public RpcServiceRequest {
+public:
+	struct ZoneMappings {
+		std::string vSwitchId;
+		std::string zoneId;
+		std::string allocationId;
+	};
+	UpdateLoadBalancerZonesRequest();
+	~UpdateLoadBalancerZonesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::vector<ZoneMappings> getZoneMappings() const;
+	void setZoneMappings(const std::vector<ZoneMappings> &zoneMappings);
+	std::string getLoadBalancerId() const;
+	void setLoadBalancerId(const std::string &loadBalancerId);
+
+private:
+	std::string clientToken_;
+	bool dryRun_;
+	std::vector<ZoneMappings> zoneMappings_;
+	std::string loadBalancerId_;
+};
+} // namespace Model
+} // namespace Alb
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESREQUEST_H_

alb/include/alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
-#define ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
+#ifndef ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/ecs/EcsExport.h>
+#include <alibabacloud/alb/AlbExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Ecs
+	namespace Alb
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ECS_EXPORT CreateDiskReplicaPairResult : public ServiceResult
+			class ALIBABACLOUD_ALB_EXPORT UpdateLoadBalancerZonesResult : public ServiceResult
 			{
 			public:
 
 
-				CreateDiskReplicaPairResult();
-				explicit CreateDiskReplicaPairResult(const std::string &payload);
-				~CreateDiskReplicaPairResult();
-				std::string getPairId()const;
+				UpdateLoadBalancerZonesResult();
+				explicit UpdateLoadBalancerZonesResult(const std::string &payload);
+				~UpdateLoadBalancerZonesResult();
+				std::string getJobId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string pairId_;
+				std::string jobId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ECS_MODEL_CREATEDISKREPLICAPAIRRESULT_H_
+#endif // !ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_H_

alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h

@@ -64,6 +64,8 @@ public:
 	void setScheduler(const std::string &scheduler);
 	std::string getServerGroupId() const;
 	void setServerGroupId(const std::string &serverGroupId);
+	bool getUpstreamKeepaliveEnabled() const;
+	void setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled);
 	StickySessionConfig getStickySessionConfig() const;
 	void setStickySessionConfig(const StickySessionConfig &stickySessionConfig);
 	bool getDryRun() const;
@@ -75,6 +77,7 @@ private:
 	HealthCheckConfig healthCheckConfig_;
 	std::string scheduler_;
 	std::string serverGroupId_;
+	bool upstreamKeepaliveEnabled_;
 	StickySessionConfig stickySessionConfig_;
 	bool dryRun_;
 };

alb/src/AlbClient.cc

@@ -123,6 +123,42 @@ AlbClient::AddServersToServerGroupOutcomeCallable AlbClient::addServersToServerG
 	return task->get_future();
 }
 
+AlbClient::ApplyHealthCheckTemplateToServerGroupOutcome AlbClient::applyHealthCheckTemplateToServerGroup(const ApplyHealthCheckTemplateToServerGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ApplyHealthCheckTemplateToServerGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ApplyHealthCheckTemplateToServerGroupOutcome(ApplyHealthCheckTemplateToServerGroupResult(outcome.result()));
+	else
+		return ApplyHealthCheckTemplateToServerGroupOutcome(outcome.error());
+}
+
+void AlbClient::applyHealthCheckTemplateToServerGroupAsync(const ApplyHealthCheckTemplateToServerGroupRequest& request, const ApplyHealthCheckTemplateToServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, applyHealthCheckTemplateToServerGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlbClient::ApplyHealthCheckTemplateToServerGroupOutcomeCallable AlbClient::applyHealthCheckTemplateToServerGroupCallable(const ApplyHealthCheckTemplateToServerGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ApplyHealthCheckTemplateToServerGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->applyHealthCheckTemplateToServerGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlbClient::AssociateAclsWithListenerOutcome AlbClient::associateAclsWithListener(const AssociateAclsWithListenerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +231,42 @@ AlbClient::AssociateAdditionalCertificatesWithListenerOutcomeCallable AlbClient:
 	return task->get_future();
 }
 
+AlbClient::AttachCommonBandwidthPackageToLoadBalancerOutcome AlbClient::attachCommonBandwidthPackageToLoadBalancer(const AttachCommonBandwidthPackageToLoadBalancerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachCommonBandwidthPackageToLoadBalancerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachCommonBandwidthPackageToLoadBalancerOutcome(AttachCommonBandwidthPackageToLoadBalancerResult(outcome.result()));
+	else
+		return AttachCommonBandwidthPackageToLoadBalancerOutcome(outcome.error());
+}
+
+void AlbClient::attachCommonBandwidthPackageToLoadBalancerAsync(const AttachCommonBandwidthPackageToLoadBalancerRequest& request, const AttachCommonBandwidthPackageToLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachCommonBandwidthPackageToLoadBalancer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlbClient::AttachCommonBandwidthPackageToLoadBalancerOutcomeCallable AlbClient::attachCommonBandwidthPackageToLoadBalancerCallable(const AttachCommonBandwidthPackageToLoadBalancerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachCommonBandwidthPackageToLoadBalancerOutcome()>>(
+			[this, request]()
+			{
+			return this->attachCommonBandwidthPackageToLoadBalancer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlbClient::CreateAclOutcome AlbClient::createAcl(const CreateAclRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +915,42 @@ AlbClient::DescribeZonesOutcomeCallable AlbClient::describeZonesCallable(const D
 	return task->get_future();
 }
 
+AlbClient::DetachCommonBandwidthPackageFromLoadBalancerOutcome AlbClient::detachCommonBandwidthPackageFromLoadBalancer(const DetachCommonBandwidthPackageFromLoadBalancerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachCommonBandwidthPackageFromLoadBalancerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachCommonBandwidthPackageFromLoadBalancerOutcome(DetachCommonBandwidthPackageFromLoadBalancerResult(outcome.result()));
+	else
+		return DetachCommonBandwidthPackageFromLoadBalancerOutcome(outcome.error());
+}
+
+void AlbClient::detachCommonBandwidthPackageFromLoadBalancerAsync(const DetachCommonBandwidthPackageFromLoadBalancerRequest& request, const DetachCommonBandwidthPackageFromLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachCommonBandwidthPackageFromLoadBalancer(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlbClient::DetachCommonBandwidthPackageFromLoadBalancerOutcomeCallable AlbClient::detachCommonBandwidthPackageFromLoadBalancerCallable(const DetachCommonBandwidthPackageFromLoadBalancerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachCommonBandwidthPackageFromLoadBalancerOutcome()>>(
+			[this, request]()
+			{
+			return this->detachCommonBandwidthPackageFromLoadBalancer(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlbClient::DisableDeletionProtectionOutcome AlbClient::disableDeletionProtection(const DisableDeletionProtectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,6 +1239,42 @@ AlbClient::GetListenerAttributeOutcomeCallable AlbClient::getListenerAttributeCa
 	return task->get_future();
 }
 
+AlbClient::GetListenerHealthStatusOutcome AlbClient::getListenerHealthStatus(const GetListenerHealthStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetListenerHealthStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetListenerHealthStatusOutcome(GetListenerHealthStatusResult(outcome.result()));
+	else
+		return GetListenerHealthStatusOutcome(outcome.error());
+}
+
+void AlbClient::getListenerHealthStatusAsync(const GetListenerHealthStatusRequest& request, const GetListenerHealthStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getListenerHealthStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlbClient::GetListenerHealthStatusOutcomeCallable AlbClient::getListenerHealthStatusCallable(const GetListenerHealthStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetListenerHealthStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getListenerHealthStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlbClient::GetLoadBalancerAttributeOutcome AlbClient::getLoadBalancerAttribute(const GetLoadBalancerAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2427,42 @@ AlbClient::UpdateLoadBalancerEditionOutcomeCallable AlbClient::updateLoadBalance
 	return task->get_future();
 }
 
+AlbClient::UpdateLoadBalancerZonesOutcome AlbClient::updateLoadBalancerZones(const UpdateLoadBalancerZonesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLoadBalancerZonesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLoadBalancerZonesOutcome(UpdateLoadBalancerZonesResult(outcome.result()));
+	else
+		return UpdateLoadBalancerZonesOutcome(outcome.error());
+}
+
+void AlbClient::updateLoadBalancerZonesAsync(const UpdateLoadBalancerZonesRequest& request, const UpdateLoadBalancerZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLoadBalancerZones(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlbClient::UpdateLoadBalancerZonesOutcomeCallable AlbClient::updateLoadBalancerZonesCallable(const UpdateLoadBalancerZonesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLoadBalancerZonesOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLoadBalancerZones(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlbClient::UpdateRuleAttributeOutcome AlbClient::updateRuleAttribute(const UpdateRuleAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

alb/src/model/AddServersToServerGroupRequest.cc

@@ -50,6 +50,7 @@ std::vector<AddServersToServerGroupRequest::Servers> AddServersToServerGroupRequ
 void AddServersToServerGroupRequest::setServers(const std::vector<AddServersToServerGroupRequest::Servers> &servers) {
   servers_ = servers;
   for(int dep1 = 0; dep1 != servers.size(); dep1++) {
+    setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".RemoteIpEnabled", servers[dep1].remoteIpEnabled ? "true" : "false");
     setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".ServerType", servers[dep1].serverType);
     setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Port", std::to_string(servers[dep1].port));
     setParameter(std::string("Servers") + "." + std::to_string(dep1 + 1) + ".Description", servers[dep1].description);

alb/src/model/ApplyHealthCheckTemplateToServerGroupRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alb/model/ApplyHealthCheckTemplateToServerGroupRequest.h>
+
+using AlibabaCloud::Alb::Model::ApplyHealthCheckTemplateToServerGroupRequest;
+
+ApplyHealthCheckTemplateToServerGroupRequest::ApplyHealthCheckTemplateToServerGroupRequest()
+    : RpcServiceRequest("alb", "2020-06-16", "ApplyHealthCheckTemplateToServerGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ApplyHealthCheckTemplateToServerGroupRequest::~ApplyHealthCheckTemplateToServerGroupRequest() {}
+
+std::string ApplyHealthCheckTemplateToServerGroupRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void ApplyHealthCheckTemplateToServerGroupRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string ApplyHealthCheckTemplateToServerGroupRequest::getServerGroupId() const {
+  return serverGroupId_;
+}
+
+void ApplyHealthCheckTemplateToServerGroupRequest::setServerGroupId(const std::string &serverGroupId) {
+  serverGroupId_ = serverGroupId;
+  setParameter(std::string("ServerGroupId"), serverGroupId);
+}
+
+bool ApplyHealthCheckTemplateToServerGroupRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ApplyHealthCheckTemplateToServerGroupRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string ApplyHealthCheckTemplateToServerGroupRequest::getHealthCheckTemplateId() const {
+  return healthCheckTemplateId_;
+}
+
+void ApplyHealthCheckTemplateToServerGroupRequest::setHealthCheckTemplateId(const std::string &healthCheckTemplateId) {
+  healthCheckTemplateId_ = healthCheckTemplateId;
+  setParameter(std::string("HealthCheckTemplateId"), healthCheckTemplateId);
+}
+

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

alb/src/model/AttachCommonBandwidthPackageToLoadBalancerRequest.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/alb/model/AttachCommonBandwidthPackageToLoadBalancerRequest.h>
+
+using AlibabaCloud::Alb::Model::AttachCommonBandwidthPackageToLoadBalancerRequest;
+
+AttachCommonBandwidthPackageToLoadBalancerRequest::AttachCommonBandwidthPackageToLoadBalancerRequest()
+    : RpcServiceRequest("alb", "2020-06-16", "AttachCommonBandwidthPackageToLoadBalancer") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachCommonBandwidthPackageToLoadBalancerRequest::~AttachCommonBandwidthPackageToLoadBalancerRequest() {}
+
+std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AttachCommonBandwidthPackageToLoadBalancerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AttachCommonBandwidthPackageToLoadBalancerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getBandwidthPackageId() const {
+  return bandwidthPackageId_;
+}
+
+void AttachCommonBandwidthPackageToLoadBalancerRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) {
+  bandwidthPackageId_ = bandwidthPackageId;
+  setParameter(std::string("BandwidthPackageId"), bandwidthPackageId);
+}
+
+bool AttachCommonBandwidthPackageToLoadBalancerRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void AttachCommonBandwidthPackageToLoadBalancerRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string AttachCommonBandwidthPackageToLoadBalancerRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void AttachCommonBandwidthPackageToLoadBalancerRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

alb/src/model/AttachCommonBandwidthPackageToLoadBalancerResult.cc

@@ -14,41 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/waf-openapi/model/CreateDomainConfigResult.h>
+#include <alibabacloud/alb/model/AttachCommonBandwidthPackageToLoadBalancerResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Waf_openapi;
-using namespace AlibabaCloud::Waf_openapi::Model;
+using namespace AlibabaCloud::Alb;
+using namespace AlibabaCloud::Alb::Model;
 
-CreateDomainConfigResult::CreateDomainConfigResult() :
+AttachCommonBandwidthPackageToLoadBalancerResult::AttachCommonBandwidthPackageToLoadBalancerResult() :
 	ServiceResult()
 {}
 
-CreateDomainConfigResult::CreateDomainConfigResult(const std::string &payload) :
+AttachCommonBandwidthPackageToLoadBalancerResult::AttachCommonBandwidthPackageToLoadBalancerResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateDomainConfigResult::~CreateDomainConfigResult()
+AttachCommonBandwidthPackageToLoadBalancerResult::~AttachCommonBandwidthPackageToLoadBalancerResult()
 {}
 
-void CreateDomainConfigResult::parse(const std::string &payload)
+void AttachCommonBandwidthPackageToLoadBalancerResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto resultNode = value["Result"];
-	if(!resultNode["WafTaskId"].isNull())
-		result_.wafTaskId = resultNode["WafTaskId"].asString();
-	if(!resultNode["Status"].isNull())
-		result_.status = std::stoi(resultNode["Status"].asString());
+	if(!value["JobId"].isNull())
+		jobId_ = value["JobId"].asString();
 
 }
 
-CreateDomainConfigResult::Result CreateDomainConfigResult::getResult()const
+std::string AttachCommonBandwidthPackageToLoadBalancerResult::getJobId()const
 {
-	return result_;
+	return jobId_;
 }
 

alb/src/model/CreateLoadBalancerRequest.cc

@@ -59,11 +59,21 @@ CreateLoadBalancerRequest::LoadBalancerBillingConfig CreateLoadBalancerRequest::
 
 void CreateLoadBalancerRequest::setLoadBalancerBillingConfig(const CreateLoadBalancerRequest::LoadBalancerBillingConfig &loadBalancerBillingConfig) {
   loadBalancerBillingConfig_ = loadBalancerBillingConfig;
+  setParameter(std::string("LoadBalancerBillingConfig") + ".BandwidthPackageId", loadBalancerBillingConfig.bandwidthPackageId);
   setParameter(std::string("LoadBalancerBillingConfig") + ".InternetChargeType", loadBalancerBillingConfig.internetChargeType);
   setParameter(std::string("LoadBalancerBillingConfig") + ".InternetBandwidth", std::to_string(loadBalancerBillingConfig.internetBandwidth));
   setParameter(std::string("LoadBalancerBillingConfig") + ".PayType", loadBalancerBillingConfig.payType);
 }
 
+std::string CreateLoadBalancerRequest::getAddressIpVersion() const {
+  return addressIpVersion_;
+}
+
+void CreateLoadBalancerRequest::setAddressIpVersion(const std::string &addressIpVersion) {
+  addressIpVersion_ = addressIpVersion;
+  setParameter(std::string("AddressIpVersion"), addressIpVersion);
+}
+
 bool CreateLoadBalancerRequest::getDeletionProtectionEnabled() const {
   return deletionProtectionEnabled_;
 }
@@ -127,6 +137,7 @@ void CreateLoadBalancerRequest::setZoneMappings(const std::vector<CreateLoadBala
   for(int dep1 = 0; dep1 != zoneMappings.size(); dep1++) {
     setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".VSwitchId", zoneMappings[dep1].vSwitchId);
     setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".ZoneId", zoneMappings[dep1].zoneId);
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".AllocationId", zoneMappings[dep1].allocationId);
   }
 }
 

alb/src/model/CreateServerGroupRequest.cc

@@ -96,6 +96,15 @@ void CreateServerGroupRequest::setProtocol(const std::string &protocol) {
   setParameter(std::string("Protocol"), protocol);
 }
 
+bool CreateServerGroupRequest::getUpstreamKeepaliveEnabled() const {
+  return upstreamKeepaliveEnabled_;
+}
+
+void CreateServerGroupRequest::setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled) {
+  upstreamKeepaliveEnabled_ = upstreamKeepaliveEnabled;
+  setParameter(std::string("UpstreamKeepaliveEnabled"), upstreamKeepaliveEnabled ? "true" : "false");
+}
+
 CreateServerGroupRequest::StickySessionConfig CreateServerGroupRequest::getStickySessionConfig() const {
   return stickySessionConfig_;
 }
@@ -117,6 +126,15 @@ void CreateServerGroupRequest::setDryRun(bool dryRun) {
   setParameter(std::string("DryRun"), dryRun ? "true" : "false");
 }
 
+bool CreateServerGroupRequest::getIpv6Enabled() const {
+  return ipv6Enabled_;
+}
+
+void CreateServerGroupRequest::setIpv6Enabled(bool ipv6Enabled) {
+  ipv6Enabled_ = ipv6Enabled;
+  setParameter(std::string("Ipv6Enabled"), ipv6Enabled ? "true" : "false");
+}
+
 std::string CreateServerGroupRequest::getServerGroupType() const {
   return serverGroupType_;
 }

alb/src/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.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/alb/model/DetachCommonBandwidthPackageFromLoadBalancerRequest.h>
+
+using AlibabaCloud::Alb::Model::DetachCommonBandwidthPackageFromLoadBalancerRequest;
+
+DetachCommonBandwidthPackageFromLoadBalancerRequest::DetachCommonBandwidthPackageFromLoadBalancerRequest()
+    : RpcServiceRequest("alb", "2020-06-16", "DetachCommonBandwidthPackageFromLoadBalancer") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetachCommonBandwidthPackageFromLoadBalancerRequest::~DetachCommonBandwidthPackageFromLoadBalancerRequest() {}
+
+std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void DetachCommonBandwidthPackageFromLoadBalancerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DetachCommonBandwidthPackageFromLoadBalancerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getBandwidthPackageId() const {
+  return bandwidthPackageId_;
+}
+
+void DetachCommonBandwidthPackageFromLoadBalancerRequest::setBandwidthPackageId(const std::string &bandwidthPackageId) {
+  bandwidthPackageId_ = bandwidthPackageId;
+  setParameter(std::string("BandwidthPackageId"), bandwidthPackageId);
+}
+
+bool DetachCommonBandwidthPackageFromLoadBalancerRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void DetachCommonBandwidthPackageFromLoadBalancerRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string DetachCommonBandwidthPackageFromLoadBalancerRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void DetachCommonBandwidthPackageFromLoadBalancerRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

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

alb/src/model/GetListenerHealthStatusRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alb/model/GetListenerHealthStatusRequest.h>
+
+using AlibabaCloud::Alb::Model::GetListenerHealthStatusRequest;
+
+GetListenerHealthStatusRequest::GetListenerHealthStatusRequest()
+    : RpcServiceRequest("alb", "2020-06-16", "GetListenerHealthStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetListenerHealthStatusRequest::~GetListenerHealthStatusRequest() {}
+
+bool GetListenerHealthStatusRequest::getIncludeRule() const {
+  return includeRule_;
+}
+
+void GetListenerHealthStatusRequest::setIncludeRule(bool includeRule) {
+  includeRule_ = includeRule;
+  setParameter(std::string("IncludeRule"), includeRule ? "true" : "false");
+}
+
+std::string GetListenerHealthStatusRequest::getListenerId() const {
+  return listenerId_;
+}
+
+void GetListenerHealthStatusRequest::setListenerId(const std::string &listenerId) {
+  listenerId_ = listenerId;
+  setParameter(std::string("ListenerId"), listenerId);
+}
+
+std::string GetListenerHealthStatusRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void GetListenerHealthStatusRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+long GetListenerHealthStatusRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void GetListenerHealthStatusRequest::setMaxResults(long maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

alb/src/model/GetListenerHealthStatusResult.cc

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alb/model/GetListenerHealthStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alb;
+using namespace AlibabaCloud::Alb::Model;
+
+GetListenerHealthStatusResult::GetListenerHealthStatusResult() :
+	ServiceResult()
+{}
+
+GetListenerHealthStatusResult::GetListenerHealthStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetListenerHealthStatusResult::~GetListenerHealthStatusResult()
+{}
+
+void GetListenerHealthStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allListenerHealthStatusNode = value["ListenerHealthStatus"]["ListenerHealthStatusModel"];
+	for (auto valueListenerHealthStatusListenerHealthStatusModel : allListenerHealthStatusNode)
+	{
+		ListenerHealthStatusModel listenerHealthStatusObject;
+		if(!valueListenerHealthStatusListenerHealthStatusModel["ListenerId"].isNull())
+			listenerHealthStatusObject.listenerId = valueListenerHealthStatusListenerHealthStatusModel["ListenerId"].asString();
+		if(!valueListenerHealthStatusListenerHealthStatusModel["ListenerPort"].isNull())
+			listenerHealthStatusObject.listenerPort = std::stoi(valueListenerHealthStatusListenerHealthStatusModel["ListenerPort"].asString());
+		if(!valueListenerHealthStatusListenerHealthStatusModel["ListenerProtocol"].isNull())
+			listenerHealthStatusObject.listenerProtocol = valueListenerHealthStatusListenerHealthStatusModel["ListenerProtocol"].asString();
+		auto allServerGroupInfosNode = valueListenerHealthStatusListenerHealthStatusModel["ServerGroupInfos"]["ServerGroupHealthStatusModel"];
+		for (auto valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel : allServerGroupInfosNode)
+		{
+			ListenerHealthStatusModel::ServerGroupHealthStatusModel serverGroupInfosObject;
+			if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].isNull())
+				serverGroupInfosObject.healthCheckEnabled = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].asString();
+			if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].isNull())
+				serverGroupInfosObject.serverGroupId = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].asString();
+			if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].isNull())
+				serverGroupInfosObject.actionType = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].asString();
+			auto allNonNormalServersNode = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["NonNormalServers"]["BackendServerHealthStatusModel"];
+			for (auto valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel : allNonNormalServersNode)
+			{
+				ListenerHealthStatusModel::ServerGroupHealthStatusModel::BackendServerHealthStatusModel nonNormalServersObject;
+				if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Port"].isNull())
+					nonNormalServersObject.port = std::stoi(valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Port"].asString());
+				if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerId"].isNull())
+					nonNormalServersObject.serverId = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerId"].asString();
+				if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerIp"].isNull())
+					nonNormalServersObject.serverIp = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["ServerIp"].asString();
+				if(!valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Status"].isNull())
+					nonNormalServersObject.status = valueListenerHealthStatusListenerHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersBackendServerHealthStatusModel["Status"].asString();
+				auto reasonNode = value["Reason"];
+				if(!reasonNode["ActualResponse"].isNull())
+					nonNormalServersObject.reason.actualResponse = reasonNode["ActualResponse"].asString();
+				if(!reasonNode["ExpectedResponse"].isNull())
+					nonNormalServersObject.reason.expectedResponse = reasonNode["ExpectedResponse"].asString();
+				if(!reasonNode["ReasonCode"].isNull())
+					nonNormalServersObject.reason.reasonCode = reasonNode["ReasonCode"].asString();
+				serverGroupInfosObject.nonNormalServers.push_back(nonNormalServersObject);
+			}
+			listenerHealthStatusObject.serverGroupInfos.push_back(serverGroupInfosObject);
+		}
+		listenerHealthStatus_.push_back(listenerHealthStatusObject);
+	}
+	auto allRuleHealthStatusNode = value["RuleHealthStatus"]["RuleHealthStatusModel"];
+	for (auto valueRuleHealthStatusRuleHealthStatusModel : allRuleHealthStatusNode)
+	{
+		RuleHealthStatusModel ruleHealthStatusObject;
+		if(!valueRuleHealthStatusRuleHealthStatusModel["RuleId"].isNull())
+			ruleHealthStatusObject.ruleId = valueRuleHealthStatusRuleHealthStatusModel["RuleId"].asString();
+		auto allServerGroupInfos1Node = valueRuleHealthStatusRuleHealthStatusModel["ServerGroupInfos"]["ServerGroupHealthStatusModel"];
+		for (auto valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel : allServerGroupInfos1Node)
+		{
+			RuleHealthStatusModel::ServerGroupHealthStatusModel2 serverGroupInfos1Object;
+			if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].isNull())
+				serverGroupInfos1Object.healthCheckEnabled = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["HealthCheckEnabled"].asString();
+			if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].isNull())
+				serverGroupInfos1Object.serverGroupId = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ServerGroupId"].asString();
+			if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].isNull())
+				serverGroupInfos1Object.actionType = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["ActionType"].asString();
+			auto allNonNormalServers3Node = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModel["NonNormalServers"]["NonNormalServer"];
+			for (auto valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer : allNonNormalServers3Node)
+			{
+				RuleHealthStatusModel::ServerGroupHealthStatusModel2::NonNormalServer nonNormalServers3Object;
+				if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Port"].isNull())
+					nonNormalServers3Object.port = std::stoi(valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Port"].asString());
+				if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerId"].isNull())
+					nonNormalServers3Object.serverId = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerId"].asString();
+				if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerIp"].isNull())
+					nonNormalServers3Object.serverIp = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["ServerIp"].asString();
+				if(!valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Status"].isNull())
+					nonNormalServers3Object.status = valueRuleHealthStatusRuleHealthStatusModelServerGroupInfosServerGroupHealthStatusModelNonNormalServersNonNormalServer["Status"].asString();
+				auto reason4Node = value["Reason"];
+				if(!reason4Node["ActualResponse"].isNull())
+					nonNormalServers3Object.reason4.actualResponse = reason4Node["ActualResponse"].asString();
+				if(!reason4Node["ExpectedResponse"].isNull())
+					nonNormalServers3Object.reason4.expectedResponse = reason4Node["ExpectedResponse"].asString();
+				if(!reason4Node["ReasonCode"].isNull())
+					nonNormalServers3Object.reason4.reasonCode = reason4Node["ReasonCode"].asString();
+				serverGroupInfos1Object.nonNormalServers3.push_back(nonNormalServers3Object);
+			}
+			ruleHealthStatusObject.serverGroupInfos1.push_back(serverGroupInfos1Object);
+		}
+		ruleHealthStatus_.push_back(ruleHealthStatusObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::vector<GetListenerHealthStatusResult::RuleHealthStatusModel> GetListenerHealthStatusResult::getRuleHealthStatus()const
+{
+	return ruleHealthStatus_;
+}
+
+std::vector<GetListenerHealthStatusResult::ListenerHealthStatusModel> GetListenerHealthStatusResult::getListenerHealthStatus()const
+{
+	return listenerHealthStatus_;
+}
+
+std::string GetListenerHealthStatusResult::getNextToken()const
+{
+	return nextToken_;
+}
+

alb/src/model/GetLoadBalancerAttributeResult.cc

@@ -73,6 +73,8 @@ void GetLoadBalancerAttributeResult::parse(const std::string &payload)
 			ZoneMapping::LoadBalancerAddress loadBalancerAddressesObject;
 			if(!valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Address"].isNull())
 				loadBalancerAddressesObject.address = valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Address"].asString();
+			if(!valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Ipv6Address"].isNull())
+				loadBalancerAddressesObject.ipv6Address = valueZoneMappingsZoneMappingLoadBalancerAddressesLoadBalancerAddress["Ipv6Address"].asString();
 			zoneMappingsObject.loadBalancerAddresses.push_back(loadBalancerAddressesObject);
 		}
 		zoneMappings_.push_back(zoneMappingsObject);
@@ -134,6 +136,12 @@ void GetLoadBalancerAttributeResult::parse(const std::string &payload)
 		resourceGroupId_ = value["ResourceGroupId"].asString();
 	if(!value["VpcId"].isNull())
 		vpcId_ = value["VpcId"].asString();
+	if(!value["ConfigManagedEnabled"].isNull())
+		configManagedEnabled_ = value["ConfigManagedEnabled"].asString() == "true";
+	if(!value["AddressIpVersion"].isNull())
+		addressIpVersion_ = value["AddressIpVersion"].asString();
+	if(!value["Ipv6AddressType"].isNull())
+		ipv6AddressType_ = value["Ipv6AddressType"].asString();
 
 }
 
@@ -142,9 +150,9 @@ bool GetLoadBalancerAttributeResult::getServiceManagedEnabled()const
 	return serviceManagedEnabled_;
 }
 
-std::string GetLoadBalancerAttributeResult::getLoadBalancerEdition()const
+std::string GetLoadBalancerAttributeResult::getAddressIpVersion()const
 {
-	return loadBalancerEdition_;
+	return addressIpVersion_;
 }
 
 std::string GetLoadBalancerAttributeResult::getResourceGroupId()const
@@ -152,21 +160,11 @@ std::string GetLoadBalancerAttributeResult::getResourceGroupId()const
 	return resourceGroupId_;
 }
 
-GetLoadBalancerAttributeResult::LoadBalancerBillingConfig GetLoadBalancerAttributeResult::getLoadBalancerBillingConfig()const
-{
-	return loadBalancerBillingConfig_;
-}
-
 std::vector<std::string> GetLoadBalancerAttributeResult::getFeatureLabels()const
 {
 	return featureLabels_;
 }
 
-std::string GetLoadBalancerAttributeResult::getCreateTime()const
-{
-	return createTime_;
-}
-
 std::string GetLoadBalancerAttributeResult::getLoadBalancerId()const
 {
 	return loadBalancerId_;
@@ -182,6 +180,51 @@ std::string GetLoadBalancerAttributeResult::getDNSName()const
 	return dNSName_;
 }
 
+std::string GetLoadBalancerAttributeResult::getIpv6AddressType()const
+{
+	return ipv6AddressType_;
+}
+
+int GetLoadBalancerAttributeResult::getBandwidthCapacity()const
+{
+	return bandwidthCapacity_;
+}
+
+GetLoadBalancerAttributeResult::DeletionProtectionConfig GetLoadBalancerAttributeResult::getDeletionProtectionConfig()const
+{
+	return deletionProtectionConfig_;
+}
+
+std::string GetLoadBalancerAttributeResult::getServiceManagedMode()const
+{
+	return serviceManagedMode_;
+}
+
+std::string GetLoadBalancerAttributeResult::getBandwidthPackageId()const
+{
+	return bandwidthPackageId_;
+}
+
+std::vector<GetLoadBalancerAttributeResult::Tag> GetLoadBalancerAttributeResult::getTags()const
+{
+	return tags_;
+}
+
+std::string GetLoadBalancerAttributeResult::getLoadBalancerEdition()const
+{
+	return loadBalancerEdition_;
+}
+
+GetLoadBalancerAttributeResult::LoadBalancerBillingConfig GetLoadBalancerAttributeResult::getLoadBalancerBillingConfig()const
+{
+	return loadBalancerBillingConfig_;
+}
+
+std::string GetLoadBalancerAttributeResult::getCreateTime()const
+{
+	return createTime_;
+}
+
 GetLoadBalancerAttributeResult::ModificationProtectionConfig GetLoadBalancerAttributeResult::getModificationProtectionConfig()const
 {
 	return modificationProtectionConfig_;
@@ -197,14 +240,9 @@ GetLoadBalancerAttributeResult::AccessLogConfig GetLoadBalancerAttributeResult::
 	return accessLogConfig_;
 }
 
-int GetLoadBalancerAttributeResult::getBandwidthCapacity()const
+bool GetLoadBalancerAttributeResult::getConfigManagedEnabled()const
 {
-	return bandwidthCapacity_;
-}
-
-GetLoadBalancerAttributeResult::DeletionProtectionConfig GetLoadBalancerAttributeResult::getDeletionProtectionConfig()const
-{
-	return deletionProtectionConfig_;
+	return configManagedEnabled_;
 }
 
 std::string GetLoadBalancerAttributeResult::getLoadBalancerBussinessStatus()const
@@ -217,16 +255,6 @@ std::string GetLoadBalancerAttributeResult::getVpcId()const
 	return vpcId_;
 }
 
-std::string GetLoadBalancerAttributeResult::getServiceManagedMode()const
-{
-	return serviceManagedMode_;
-}
-
-std::string GetLoadBalancerAttributeResult::getBandwidthPackageId()const
-{
-	return bandwidthPackageId_;
-}
-
 std::string GetLoadBalancerAttributeResult::getRegionId()const
 {
 	return regionId_;
@@ -247,11 +275,6 @@ std::string GetLoadBalancerAttributeResult::getLoadBalancerStatus()const
 	return loadBalancerStatus_;
 }
 
-std::vector<GetLoadBalancerAttributeResult::Tag> GetLoadBalancerAttributeResult::getTags()const
-{
-	return tags_;
-}
-
 std::vector<GetLoadBalancerAttributeResult::LoadBalancerOperationLock> GetLoadBalancerAttributeResult::getLoadBalancerOperationLocks()const
 {
 	return loadBalancerOperationLocks_;

alb/src/model/ListAclsResult.cc

@@ -57,6 +57,8 @@ void ListAclsResult::parse(const std::string &payload)
 			aclsObject.serviceManagedEnabled = valueAclsAcl["ServiceManagedEnabled"].asString() == "true";
 		if(!valueAclsAcl["ServiceManagedMode"].isNull())
 			aclsObject.serviceManagedMode = valueAclsAcl["ServiceManagedMode"].asString();
+		if(!valueAclsAcl["ConfigManagedEnabled"].isNull())
+			aclsObject.configManagedEnabled = valueAclsAcl["ConfigManagedEnabled"].asString() == "true";
 		acls_.push_back(aclsObject);
 	}
 	if(!value["MaxResults"].isNull())

alb/src/model/ListLoadBalancersRequest.cc

@@ -47,6 +47,15 @@ void ListLoadBalancersRequest::setLoadBalancerIds(const std::vector<ListLoadBala
   }
 }
 
+std::string ListLoadBalancersRequest::getAddressIpVersion() const {
+  return addressIpVersion_;
+}
+
+void ListLoadBalancersRequest::setAddressIpVersion(const std::string &addressIpVersion) {
+  addressIpVersion_ = addressIpVersion;
+  setParameter(std::string("AddressIpVersion"), addressIpVersion);
+}
+
 std::string ListLoadBalancersRequest::getResourceGroupId() const {
   return resourceGroupId_;
 }
@@ -151,6 +160,15 @@ void ListLoadBalancersRequest::setZoneId(const std::string &zoneId) {
   setParameter(std::string("ZoneId"), zoneId);
 }
 
+std::string ListLoadBalancersRequest::getIpv6AddressType() const {
+  return ipv6AddressType_;
+}
+
+void ListLoadBalancersRequest::setIpv6AddressType(const std::string &ipv6AddressType) {
+  ipv6AddressType_ = ipv6AddressType;
+  setParameter(std::string("Ipv6AddressType"), ipv6AddressType);
+}
+
 std::string ListLoadBalancersRequest::getPayType() const {
   return payType_;
 }

alb/src/model/ListLoadBalancersResult.cc

@@ -73,6 +73,12 @@ void ListLoadBalancersResult::parse(const std::string &payload)
 			loadBalancersObject.resourceGroupId = valueLoadBalancersloadBalancer["ResourceGroupId"].asString();
 		if(!valueLoadBalancersloadBalancer["VpcId"].isNull())
 			loadBalancersObject.vpcId = valueLoadBalancersloadBalancer["VpcId"].asString();
+		if(!valueLoadBalancersloadBalancer["ConfigManagedEnabled"].isNull())
+			loadBalancersObject.configManagedEnabled = valueLoadBalancersloadBalancer["ConfigManagedEnabled"].asString() == "true";
+		if(!valueLoadBalancersloadBalancer["AddressIpVersion"].isNull())
+			loadBalancersObject.addressIpVersion = valueLoadBalancersloadBalancer["AddressIpVersion"].asString();
+		if(!valueLoadBalancersloadBalancer["Ipv6AddressType"].isNull())
+			loadBalancersObject.ipv6AddressType = valueLoadBalancersloadBalancer["Ipv6AddressType"].asString();
 		auto allLoadBalancerOperationLocksNode = valueLoadBalancersloadBalancer["LoadBalancerOperationLocks"]["LoadBalancerOperationLock"];
 		for (auto valueLoadBalancersloadBalancerLoadBalancerOperationLocksLoadBalancerOperationLock : allLoadBalancerOperationLocksNode)
 		{

alb/src/model/ListServerGroupServersResult.cc

@@ -59,6 +59,8 @@ void ListServerGroupServersResult::parse(const std::string &payload)
 			serversObject.weight = std::stoi(valueServersBackendServer["Weight"].asString());
 		if(!valueServersBackendServer["ServerGroupId"].isNull())
 			serversObject.serverGroupId = valueServersBackendServer["ServerGroupId"].asString();
+		if(!valueServersBackendServer["RemoteIpEnabled"].isNull())
+			serversObject.remoteIpEnabled = valueServersBackendServer["RemoteIpEnabled"].asString() == "true";
 		servers_.push_back(serversObject);
 	}
 	if(!value["MaxResults"].isNull())

alb/src/model/ListServerGroupsResult.cc

@@ -63,6 +63,14 @@ void ListServerGroupsResult::parse(const std::string &payload)
 			serverGroupsObject.serviceManagedEnabled = valueServerGroupsServerGroup["ServiceManagedEnabled"].asString() == "true";
 		if(!valueServerGroupsServerGroup["ServiceManagedMode"].isNull())
 			serverGroupsObject.serviceManagedMode = valueServerGroupsServerGroup["ServiceManagedMode"].asString();
+		if(!valueServerGroupsServerGroup["ConfigManagedEnabled"].isNull())
+			serverGroupsObject.configManagedEnabled = valueServerGroupsServerGroup["ConfigManagedEnabled"].asString() == "true";
+		if(!valueServerGroupsServerGroup["UpstreamKeepaliveEnabled"].isNull())
+			serverGroupsObject.upstreamKeepaliveEnabled = valueServerGroupsServerGroup["UpstreamKeepaliveEnabled"].asString() == "true";
+		if(!valueServerGroupsServerGroup["Ipv6Enabled"].isNull())
+			serverGroupsObject.ipv6Enabled = valueServerGroupsServerGroup["Ipv6Enabled"].asString() == "true";
+		if(!valueServerGroupsServerGroup["ServerCount"].isNull())
+			serverGroupsObject.serverCount = std::stoi(valueServerGroupsServerGroup["ServerCount"].asString());
 		auto allTagsNode = valueServerGroupsServerGroup["Tags"]["Tag"];
 		for (auto valueServerGroupsServerGroupTagsTag : allTagsNode)
 		{

alb/src/model/ReplaceServersInServerGroupRequest.cc

@@ -50,6 +50,7 @@ std::vector<ReplaceServersInServerGroupRequest::AddedServers> ReplaceServersInSe
 void ReplaceServersInServerGroupRequest::setAddedServers(const std::vector<ReplaceServersInServerGroupRequest::AddedServers> &addedServers) {
   addedServers_ = addedServers;
   for(int dep1 = 0; dep1 != addedServers.size(); dep1++) {
+    setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".RemoteIpEnabled", addedServers[dep1].remoteIpEnabled ? "true" : "false");
     setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".ServerType", addedServers[dep1].serverType);
     setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".Port", std::to_string(addedServers[dep1].port));
     setParameter(std::string("AddedServers") + "." + std::to_string(dep1 + 1) + ".Description", addedServers[dep1].description);

alb/src/model/UpdateLoadBalancerZonesRequest.cc

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alb/model/UpdateLoadBalancerZonesRequest.h>
+
+using AlibabaCloud::Alb::Model::UpdateLoadBalancerZonesRequest;
+
+UpdateLoadBalancerZonesRequest::UpdateLoadBalancerZonesRequest()
+    : RpcServiceRequest("alb", "2020-06-16", "UpdateLoadBalancerZones") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateLoadBalancerZonesRequest::~UpdateLoadBalancerZonesRequest() {}
+
+std::string UpdateLoadBalancerZonesRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void UpdateLoadBalancerZonesRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+bool UpdateLoadBalancerZonesRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void UpdateLoadBalancerZonesRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::vector<UpdateLoadBalancerZonesRequest::ZoneMappings> UpdateLoadBalancerZonesRequest::getZoneMappings() const {
+  return zoneMappings_;
+}
+
+void UpdateLoadBalancerZonesRequest::setZoneMappings(const std::vector<UpdateLoadBalancerZonesRequest::ZoneMappings> &zoneMappings) {
+  zoneMappings_ = zoneMappings;
+  for(int dep1 = 0; dep1 != zoneMappings.size(); dep1++) {
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".VSwitchId", zoneMappings[dep1].vSwitchId);
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".ZoneId", zoneMappings[dep1].zoneId);
+    setParameter(std::string("ZoneMappings") + "." + std::to_string(dep1 + 1) + ".AllocationId", zoneMappings[dep1].allocationId);
+  }
+}
+
+std::string UpdateLoadBalancerZonesRequest::getLoadBalancerId() const {
+  return loadBalancerId_;
+}
+
+void UpdateLoadBalancerZonesRequest::setLoadBalancerId(const std::string &loadBalancerId) {
+  loadBalancerId_ = loadBalancerId;
+  setParameter(std::string("LoadBalancerId"), loadBalancerId);
+}
+

alb/src/model/UpdateLoadBalancerZonesResult.cc

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/ecs/model/CreateDiskReplicaPairResult.h>
+#include <alibabacloud/alb/model/UpdateLoadBalancerZonesResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Ecs;
-using namespace AlibabaCloud::Ecs::Model;
+using namespace AlibabaCloud::Alb;
+using namespace AlibabaCloud::Alb::Model;
 
-CreateDiskReplicaPairResult::CreateDiskReplicaPairResult() :
+UpdateLoadBalancerZonesResult::UpdateLoadBalancerZonesResult() :
 	ServiceResult()
 {}
 
-CreateDiskReplicaPairResult::CreateDiskReplicaPairResult(const std::string &payload) :
+UpdateLoadBalancerZonesResult::UpdateLoadBalancerZonesResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-CreateDiskReplicaPairResult::~CreateDiskReplicaPairResult()
+UpdateLoadBalancerZonesResult::~UpdateLoadBalancerZonesResult()
 {}
 
-void CreateDiskReplicaPairResult::parse(const std::string &payload)
+void UpdateLoadBalancerZonesResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["PairId"].isNull())
-		pairId_ = value["PairId"].asString();
+	if(!value["JobId"].isNull())
+		jobId_ = value["JobId"].asString();
 
 }
 
-std::string CreateDiskReplicaPairResult::getPairId()const
+std::string UpdateLoadBalancerZonesResult::getJobId()const
 {
-	return pairId_;
+	return jobId_;
 }
 

alb/src/model/UpdateServerGroupAttributeRequest.cc

@@ -87,6 +87,15 @@ void UpdateServerGroupAttributeRequest::setServerGroupId(const std::string &serv
   setParameter(std::string("ServerGroupId"), serverGroupId);
 }
 
+bool UpdateServerGroupAttributeRequest::getUpstreamKeepaliveEnabled() const {
+  return upstreamKeepaliveEnabled_;
+}
+
+void UpdateServerGroupAttributeRequest::setUpstreamKeepaliveEnabled(bool upstreamKeepaliveEnabled) {
+  upstreamKeepaliveEnabled_ = upstreamKeepaliveEnabled;
+  setParameter(std::string("UpstreamKeepaliveEnabled"), upstreamKeepaliveEnabled ? "true" : "false");
+}
+
 UpdateServerGroupAttributeRequest::StickySessionConfig UpdateServerGroupAttributeRequest::getStickySessionConfig() const {
   return stickySessionConfig_;
 }

cbn/include/alibabacloud/cbn/model/DescribeCenInterRegionBandwidthLimitsResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct CenInterRegionBandwidthLimit
 				{
-					std::string status;
 					std::string transitRouterAttachmentId;
+					std::string status;
 					std::string geographicSpanId;
 					std::string oppositeRegionId;
 					std::string cenId;

cbn/include/alibabacloud/cbn/model/DescribeCenVbrHealthCheckResult.h

@@ -38,12 +38,13 @@ namespace AlibabaCloud
 					std::string linkStatus;
 					int healthCheckInterval;
 					std::string vbrInstanceId;
-					std::string healthCheckSourceIp;
 					int healthyThreshold;
+					std::string healthCheckSourceIp;
 					std::string cenId;
 					long packetLoss;
 					std::string healthCheckTargetIp;
 					long delay;
+					bool healthCheckOnly;
 				};
 
 

cbn/include/alibabacloud/cbn/model/DescribeGrantRulesToCenResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct GrantRule
 				{
 					std::string childInstanceType;
+					std::string orderType;
 					std::string cenId;
 					long childInstanceOwnerId;
 					std::string childInstanceId;

cbn/include/alibabacloud/cbn/model/EnableCenVbrHealthCheckRequest.h

@@ -45,6 +45,8 @@ namespace AlibabaCloud
 				void setHealthyThreshold(int healthyThreshold);
 				long getVbrInstanceOwnerId()const;
 				void setVbrInstanceOwnerId(long vbrInstanceOwnerId);
+				bool getHealthCheckOnly()const;
+				void setHealthCheckOnly(bool healthCheckOnly);
 				std::string getVbrInstanceRegionId()const;
 				void setVbrInstanceRegionId(const std::string& vbrInstanceRegionId);
 				std::string getResourceOwnerAccount()const;
@@ -66,6 +68,7 @@ namespace AlibabaCloud
 				std::string healthCheckTargetIp_;
 				int healthyThreshold_;
 				long vbrInstanceOwnerId_;
+				bool healthCheckOnly_;
 				std::string vbrInstanceRegionId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;

cbn/src/model/DescribeCenInterRegionBandwidthLimitsResult.cc

@@ -43,30 +43,30 @@ void DescribeCenInterRegionBandwidthLimitsResult::parse(const std::string &paylo
 	for (auto valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit : allCenInterRegionBandwidthLimitsNode)
 	{
 		CenInterRegionBandwidthLimit cenInterRegionBandwidthLimitsObject;
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].isNull())
-			cenInterRegionBandwidthLimitsObject.cenId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].asString();
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].isNull())
-			cenInterRegionBandwidthLimitsObject.localRegionId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].isNull())
+			cenInterRegionBandwidthLimitsObject.transitRouterAttachmentId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].isNull())
+			cenInterRegionBandwidthLimitsObject.status = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].isNull())
+			cenInterRegionBandwidthLimitsObject.bandwidthPackageId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].asString();
 		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["OppositeRegionId"].isNull())
 			cenInterRegionBandwidthLimitsObject.oppositeRegionId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["OppositeRegionId"].asString();
 		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["GeographicSpanId"].isNull())
 			cenInterRegionBandwidthLimitsObject.geographicSpanId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["GeographicSpanId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].isNull())
+			cenInterRegionBandwidthLimitsObject.cenId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["CenId"].asString();
+		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].isNull())
+			cenInterRegionBandwidthLimitsObject.localRegionId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["LocalRegionId"].asString();
 		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthLimit"].isNull())
 			cenInterRegionBandwidthLimitsObject.bandwidthLimit = std::stol(valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthLimit"].asString());
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].isNull())
-			cenInterRegionBandwidthLimitsObject.status = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["Status"].asString();
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].isNull())
-			cenInterRegionBandwidthLimitsObject.transitRouterAttachmentId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["TransitRouterAttachmentId"].asString();
-		if(!valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].isNull())
-			cenInterRegionBandwidthLimitsObject.bandwidthPackageId = valueCenInterRegionBandwidthLimitsCenInterRegionBandwidthLimit["BandwidthPackageId"].asString();
 		cenInterRegionBandwidthLimits_.push_back(cenInterRegionBandwidthLimitsObject);
 	}
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 

cbn/src/model/DescribeCenVbrHealthCheckResult.cc

@@ -43,34 +43,36 @@ void DescribeCenVbrHealthCheckResult::parse(const std::string &payload)
 	for (auto valueVbrHealthChecksVbrHealthCheck : allVbrHealthChecksNode)
 	{
 		VbrHealthCheck vbrHealthChecksObject;
-		if(!valueVbrHealthChecksVbrHealthCheck["CenId"].isNull())
-			vbrHealthChecksObject.cenId = valueVbrHealthChecksVbrHealthCheck["CenId"].asString();
-		if(!valueVbrHealthChecksVbrHealthCheck["VbrInstanceId"].isNull())
-			vbrHealthChecksObject.vbrInstanceId = valueVbrHealthChecksVbrHealthCheck["VbrInstanceId"].asString();
-		if(!valueVbrHealthChecksVbrHealthCheck["LinkStatus"].isNull())
-			vbrHealthChecksObject.linkStatus = valueVbrHealthChecksVbrHealthCheck["LinkStatus"].asString();
-		if(!valueVbrHealthChecksVbrHealthCheck["PacketLoss"].isNull())
-			vbrHealthChecksObject.packetLoss = std::stol(valueVbrHealthChecksVbrHealthCheck["PacketLoss"].asString());
-		if(!valueVbrHealthChecksVbrHealthCheck["HealthCheckSourceIp"].isNull())
-			vbrHealthChecksObject.healthCheckSourceIp = valueVbrHealthChecksVbrHealthCheck["HealthCheckSourceIp"].asString();
 		if(!valueVbrHealthChecksVbrHealthCheck["HealthCheckTargetIp"].isNull())
 			vbrHealthChecksObject.healthCheckTargetIp = valueVbrHealthChecksVbrHealthCheck["HealthCheckTargetIp"].asString();
-		if(!valueVbrHealthChecksVbrHealthCheck["Delay"].isNull())
-			vbrHealthChecksObject.delay = std::stol(valueVbrHealthChecksVbrHealthCheck["Delay"].asString());
-		if(!valueVbrHealthChecksVbrHealthCheck["HealthCheckInterval"].isNull())
-			vbrHealthChecksObject.healthCheckInterval = std::stoi(valueVbrHealthChecksVbrHealthCheck["HealthCheckInterval"].asString());
-		if(!valueVbrHealthChecksVbrHealthCheck["HealthyThreshold"].isNull())
-			vbrHealthChecksObject.healthyThreshold = std::stoi(valueVbrHealthChecksVbrHealthCheck["HealthyThreshold"].asString());
+		if(!valueVbrHealthChecksVbrHealthCheck["VbrInstanceId"].isNull())
+			vbrHealthChecksObject.vbrInstanceId = valueVbrHealthChecksVbrHealthCheck["VbrInstanceId"].asString();
 		if(!valueVbrHealthChecksVbrHealthCheck["VbrInstanceRegionId"].isNull())
 			vbrHealthChecksObject.vbrInstanceRegionId = valueVbrHealthChecksVbrHealthCheck["VbrInstanceRegionId"].asString();
+		if(!valueVbrHealthChecksVbrHealthCheck["Delay"].isNull())
+			vbrHealthChecksObject.delay = std::stol(valueVbrHealthChecksVbrHealthCheck["Delay"].asString());
+		if(!valueVbrHealthChecksVbrHealthCheck["LinkStatus"].isNull())
+			vbrHealthChecksObject.linkStatus = valueVbrHealthChecksVbrHealthCheck["LinkStatus"].asString();
+		if(!valueVbrHealthChecksVbrHealthCheck["CenId"].isNull())
+			vbrHealthChecksObject.cenId = valueVbrHealthChecksVbrHealthCheck["CenId"].asString();
+		if(!valueVbrHealthChecksVbrHealthCheck["HealthyThreshold"].isNull())
+			vbrHealthChecksObject.healthyThreshold = std::stoi(valueVbrHealthChecksVbrHealthCheck["HealthyThreshold"].asString());
+		if(!valueVbrHealthChecksVbrHealthCheck["HealthCheckInterval"].isNull())
+			vbrHealthChecksObject.healthCheckInterval = std::stoi(valueVbrHealthChecksVbrHealthCheck["HealthCheckInterval"].asString());
+		if(!valueVbrHealthChecksVbrHealthCheck["HealthCheckSourceIp"].isNull())
+			vbrHealthChecksObject.healthCheckSourceIp = valueVbrHealthChecksVbrHealthCheck["HealthCheckSourceIp"].asString();
+		if(!valueVbrHealthChecksVbrHealthCheck["PacketLoss"].isNull())
+			vbrHealthChecksObject.packetLoss = std::stol(valueVbrHealthChecksVbrHealthCheck["PacketLoss"].asString());
+		if(!valueVbrHealthChecksVbrHealthCheck["HealthCheckOnly"].isNull())
+			vbrHealthChecksObject.healthCheckOnly = valueVbrHealthChecksVbrHealthCheck["HealthCheckOnly"].asString() == "true";
 		vbrHealthChecks_.push_back(vbrHealthChecksObject);
 	}
-	if(!value["TotalCount"].isNull())
-		totalCount_ = std::stoi(value["TotalCount"].asString());
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
 
 }
 

cbn/src/model/DescribeGrantRulesToCenResult.cc

@@ -43,16 +43,18 @@ void DescribeGrantRulesToCenResult::parse(const std::string &payload)
 	for (auto valueGrantRulesGrantRule : allGrantRulesNode)
 	{
 		GrantRule grantRulesObject;
-		if(!valueGrantRulesGrantRule["CenId"].isNull())
-			grantRulesObject.cenId = valueGrantRulesGrantRule["CenId"].asString();
-		if(!valueGrantRulesGrantRule["ChildInstanceRegionId"].isNull())
-			grantRulesObject.childInstanceRegionId = valueGrantRulesGrantRule["ChildInstanceRegionId"].asString();
 		if(!valueGrantRulesGrantRule["ChildInstanceType"].isNull())
 			grantRulesObject.childInstanceType = valueGrantRulesGrantRule["ChildInstanceType"].asString();
-		if(!valueGrantRulesGrantRule["ChildInstanceId"].isNull())
-			grantRulesObject.childInstanceId = valueGrantRulesGrantRule["ChildInstanceId"].asString();
+		if(!valueGrantRulesGrantRule["ChildInstanceRegionId"].isNull())
+			grantRulesObject.childInstanceRegionId = valueGrantRulesGrantRule["ChildInstanceRegionId"].asString();
 		if(!valueGrantRulesGrantRule["ChildInstanceOwnerId"].isNull())
 			grantRulesObject.childInstanceOwnerId = std::stol(valueGrantRulesGrantRule["ChildInstanceOwnerId"].asString());
+		if(!valueGrantRulesGrantRule["ChildInstanceId"].isNull())
+			grantRulesObject.childInstanceId = valueGrantRulesGrantRule["ChildInstanceId"].asString();
+		if(!valueGrantRulesGrantRule["CenId"].isNull())
+			grantRulesObject.cenId = valueGrantRulesGrantRule["CenId"].asString();
+		if(!valueGrantRulesGrantRule["OrderType"].isNull())
+			grantRulesObject.orderType = valueGrantRulesGrantRule["OrderType"].asString();
 		grantRules_.push_back(grantRulesObject);
 	}
 

cbn/src/model/EnableCenVbrHealthCheckRequest.cc

@@ -82,6 +82,17 @@ void EnableCenVbrHealthCheckRequest::setVbrInstanceOwnerId(long vbrInstanceOwner
 	setParameter("VbrInstanceOwnerId", std::to_string(vbrInstanceOwnerId));
 }
 
+bool EnableCenVbrHealthCheckRequest::getHealthCheckOnly()const
+{
+	return healthCheckOnly_;
+}
+
+void EnableCenVbrHealthCheckRequest::setHealthCheckOnly(bool healthCheckOnly)
+{
+	healthCheckOnly_ = healthCheckOnly;
+	setParameter("HealthCheckOnly", healthCheckOnly ? "true" : "false");
+}
+
 std::string EnableCenVbrHealthCheckRequest::getVbrInstanceRegionId()const
 {
 	return vbrInstanceRegionId_;

cms/CMakeLists.txt

@@ -39,6 +39,8 @@ set(cms_public_header_model
 	include/alibabacloud/cms/model/CreateGroupMonitoringAgentProcessResult.h
 	include/alibabacloud/cms/model/CreateHostAvailabilityRequest.h
 	include/alibabacloud/cms/model/CreateHostAvailabilityResult.h
+	include/alibabacloud/cms/model/CreateInstantSiteMonitorRequest.h
+	include/alibabacloud/cms/model/CreateInstantSiteMonitorResult.h
 	include/alibabacloud/cms/model/CreateMetricRuleResourcesRequest.h
 	include/alibabacloud/cms/model/CreateMetricRuleResourcesResult.h
 	include/alibabacloud/cms/model/CreateMetricRuleTemplateRequest.h
@@ -205,6 +207,8 @@ set(cms_public_header_model
 	include/alibabacloud/cms/model/DescribeSiteMonitorISPCityListResult.h
 	include/alibabacloud/cms/model/DescribeSiteMonitorListRequest.h
 	include/alibabacloud/cms/model/DescribeSiteMonitorListResult.h
+	include/alibabacloud/cms/model/DescribeSiteMonitorLogRequest.h
+	include/alibabacloud/cms/model/DescribeSiteMonitorLogResult.h
 	include/alibabacloud/cms/model/DescribeSiteMonitorQuotaRequest.h
 	include/alibabacloud/cms/model/DescribeSiteMonitorQuotaResult.h
 	include/alibabacloud/cms/model/DescribeSiteMonitorStatisticsRequest.h
@@ -322,6 +326,8 @@ set(cms_src
 	src/model/CreateGroupMonitoringAgentProcessResult.cc
 	src/model/CreateHostAvailabilityRequest.cc
 	src/model/CreateHostAvailabilityResult.cc
+	src/model/CreateInstantSiteMonitorRequest.cc
+	src/model/CreateInstantSiteMonitorResult.cc
 	src/model/CreateMetricRuleResourcesRequest.cc
 	src/model/CreateMetricRuleResourcesResult.cc
 	src/model/CreateMetricRuleTemplateRequest.cc
@@ -488,6 +494,8 @@ set(cms_src
 	src/model/DescribeSiteMonitorISPCityListResult.cc
 	src/model/DescribeSiteMonitorListRequest.cc
 	src/model/DescribeSiteMonitorListResult.cc
+	src/model/DescribeSiteMonitorLogRequest.cc
+	src/model/DescribeSiteMonitorLogResult.cc
 	src/model/DescribeSiteMonitorQuotaRequest.cc
 	src/model/DescribeSiteMonitorQuotaResult.cc
 	src/model/DescribeSiteMonitorStatisticsRequest.cc

cms/include/alibabacloud/cms/CmsClient.h

@@ -40,6 +40,8 @@
 #include "model/CreateGroupMonitoringAgentProcessResult.h"
 #include "model/CreateHostAvailabilityRequest.h"
 #include "model/CreateHostAvailabilityResult.h"
+#include "model/CreateInstantSiteMonitorRequest.h"
+#include "model/CreateInstantSiteMonitorResult.h"
 #include "model/CreateMetricRuleResourcesRequest.h"
 #include "model/CreateMetricRuleResourcesResult.h"
 #include "model/CreateMetricRuleTemplateRequest.h"
@@ -206,6 +208,8 @@
 #include "model/DescribeSiteMonitorISPCityListResult.h"
 #include "model/DescribeSiteMonitorListRequest.h"
 #include "model/DescribeSiteMonitorListResult.h"
+#include "model/DescribeSiteMonitorLogRequest.h"
+#include "model/DescribeSiteMonitorLogResult.h"
 #include "model/DescribeSiteMonitorQuotaRequest.h"
 #include "model/DescribeSiteMonitorQuotaResult.h"
 #include "model/DescribeSiteMonitorStatisticsRequest.h"
@@ -338,6 +342,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateHostAvailabilityResult> CreateHostAvailabilityOutcome;
 			typedef std::future<CreateHostAvailabilityOutcome> CreateHostAvailabilityOutcomeCallable;
 			typedef std::function<void(const CmsClient*, const Model::CreateHostAvailabilityRequest&, const CreateHostAvailabilityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHostAvailabilityAsyncHandler;
+			typedef Outcome<Error, Model::CreateInstantSiteMonitorResult> CreateInstantSiteMonitorOutcome;
+			typedef std::future<CreateInstantSiteMonitorOutcome> CreateInstantSiteMonitorOutcomeCallable;
+			typedef std::function<void(const CmsClient*, const Model::CreateInstantSiteMonitorRequest&, const CreateInstantSiteMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateInstantSiteMonitorAsyncHandler;
 			typedef Outcome<Error, Model::CreateMetricRuleResourcesResult> CreateMetricRuleResourcesOutcome;
 			typedef std::future<CreateMetricRuleResourcesOutcome> CreateMetricRuleResourcesOutcomeCallable;
 			typedef std::function<void(const CmsClient*, const Model::CreateMetricRuleResourcesRequest&, const CreateMetricRuleResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMetricRuleResourcesAsyncHandler;
@@ -587,6 +594,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeSiteMonitorListResult> DescribeSiteMonitorListOutcome;
 			typedef std::future<DescribeSiteMonitorListOutcome> DescribeSiteMonitorListOutcomeCallable;
 			typedef std::function<void(const CmsClient*, const Model::DescribeSiteMonitorListRequest&, const DescribeSiteMonitorListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSiteMonitorListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSiteMonitorLogResult> DescribeSiteMonitorLogOutcome;
+			typedef std::future<DescribeSiteMonitorLogOutcome> DescribeSiteMonitorLogOutcomeCallable;
+			typedef std::function<void(const CmsClient*, const Model::DescribeSiteMonitorLogRequest&, const DescribeSiteMonitorLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSiteMonitorLogAsyncHandler;
 			typedef Outcome<Error, Model::DescribeSiteMonitorQuotaResult> DescribeSiteMonitorQuotaOutcome;
 			typedef std::future<DescribeSiteMonitorQuotaOutcome> DescribeSiteMonitorQuotaOutcomeCallable;
 			typedef std::function<void(const CmsClient*, const Model::DescribeSiteMonitorQuotaRequest&, const DescribeSiteMonitorQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSiteMonitorQuotaAsyncHandler;
@@ -763,6 +773,9 @@ namespace AlibabaCloud
 			CreateHostAvailabilityOutcome createHostAvailability(const Model::CreateHostAvailabilityRequest &request)const;
 			void createHostAvailabilityAsync(const Model::CreateHostAvailabilityRequest& request, const CreateHostAvailabilityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateHostAvailabilityOutcomeCallable createHostAvailabilityCallable(const Model::CreateHostAvailabilityRequest& request) const;
+			CreateInstantSiteMonitorOutcome createInstantSiteMonitor(const Model::CreateInstantSiteMonitorRequest &request)const;
+			void createInstantSiteMonitorAsync(const Model::CreateInstantSiteMonitorRequest& request, const CreateInstantSiteMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateInstantSiteMonitorOutcomeCallable createInstantSiteMonitorCallable(const Model::CreateInstantSiteMonitorRequest& request) const;
 			CreateMetricRuleResourcesOutcome createMetricRuleResources(const Model::CreateMetricRuleResourcesRequest &request)const;
 			void createMetricRuleResourcesAsync(const Model::CreateMetricRuleResourcesRequest& request, const CreateMetricRuleResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateMetricRuleResourcesOutcomeCallable createMetricRuleResourcesCallable(const Model::CreateMetricRuleResourcesRequest& request) const;
@@ -1012,6 +1025,9 @@ namespace AlibabaCloud
 			DescribeSiteMonitorListOutcome describeSiteMonitorList(const Model::DescribeSiteMonitorListRequest &request)const;
 			void describeSiteMonitorListAsync(const Model::DescribeSiteMonitorListRequest& request, const DescribeSiteMonitorListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSiteMonitorListOutcomeCallable describeSiteMonitorListCallable(const Model::DescribeSiteMonitorListRequest& request) const;
+			DescribeSiteMonitorLogOutcome describeSiteMonitorLog(const Model::DescribeSiteMonitorLogRequest &request)const;
+			void describeSiteMonitorLogAsync(const Model::DescribeSiteMonitorLogRequest& request, const DescribeSiteMonitorLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSiteMonitorLogOutcomeCallable describeSiteMonitorLogCallable(const Model::DescribeSiteMonitorLogRequest& request) const;
 			DescribeSiteMonitorQuotaOutcome describeSiteMonitorQuota(const Model::DescribeSiteMonitorQuotaRequest &request)const;
 			void describeSiteMonitorQuotaAsync(const Model::DescribeSiteMonitorQuotaRequest& request, const DescribeSiteMonitorQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSiteMonitorQuotaOutcomeCallable describeSiteMonitorQuotaCallable(const Model::DescribeSiteMonitorQuotaRequest& request) const;

cms/include/alibabacloud/cms/model/CreateInstantSiteMonitorRequest.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_CMS_MODEL_CREATEINSTANTSITEMONITORREQUEST_H_
+#define ALIBABACLOUD_CMS_MODEL_CREATEINSTANTSITEMONITORREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/cms/CmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CMS_EXPORT CreateInstantSiteMonitorRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateInstantSiteMonitorRequest();
+				~CreateInstantSiteMonitorRequest();
+
+				int getRandomIspCity()const;
+				void setRandomIspCity(int randomIspCity);
+				std::string getAddress()const;
+				void setAddress(const std::string& address);
+				std::string getTaskType()const;
+				void setTaskType(const std::string& taskType);
+				std::string getTaskName()const;
+				void setTaskName(const std::string& taskName);
+				std::string getIspCities()const;
+				void setIspCities(const std::string& ispCities);
+				std::string getOptionsJson()const;
+				void setOptionsJson(const std::string& optionsJson);
+
+            private:
+				int randomIspCity_;
+				std::string address_;
+				std::string taskType_;
+				std::string taskName_;
+				std::string ispCities_;
+				std::string optionsJson_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CMS_MODEL_CREATEINSTANTSITEMONITORREQUEST_H_

cms/include/alibabacloud/cms/model/CreateInstantSiteMonitorResult.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_CMS_MODEL_CREATEINSTANTSITEMONITORRESULT_H_
+#define ALIBABACLOUD_CMS_MODEL_CREATEINSTANTSITEMONITORRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cms/CmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CMS_EXPORT CreateInstantSiteMonitorResult : public ServiceResult
+			{
+			public:
+				struct CreateResultListItem
+				{
+					std::string taskId;
+					std::string taskName;
+				};
+
+
+				CreateInstantSiteMonitorResult();
+				explicit CreateInstantSiteMonitorResult(const std::string &payload);
+				~CreateInstantSiteMonitorResult();
+				std::string getMessage()const;
+				std::vector<CreateResultListItem> getCreateResultList()const;
+				std::string getCode()const;
+				std::string getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::vector<CreateResultListItem> createResultList_;
+				std::string code_;
+				std::string success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CMS_MODEL_CREATEINSTANTSITEMONITORRESULT_H_

cms/include/alibabacloud/cms/model/DescribeMetricRuleListResult.h

@@ -81,28 +81,48 @@ namespace AlibabaCloud
 						std::string expressionListJoin;
 						std::vector<ExpressionListItem> expressionList;
 					};
+					struct Prometheus
+					{
+						struct AnnotationsItem
+						{
+							std::string value;
+							std::string key;
+						};
+						std::vector<AnnotationsItem> annotations;
+						std::string promQL;
+						long times;
+						std::string level;
+					};
+					struct LabelsItem
+					{
+						std::string value;
+						std::string key;
+					};
 					std::string groupName;
-					int silenceTime;
-					std::string contactGroups;
 					std::string noEffectiveInterval;
-					std::string groupBy;
+					std::string options;
 					std::string mailSubject;
 					std::string sourceType;
 					std::string ruleId;
+					Prometheus prometheus;
+					std::string metricName;
+					CompositeExpression compositeExpression;
+					std::string ruleName;
+					int silenceTime;
+					std::string contactGroups;
+					std::string groupBy;
 					std::string period;
 					std::string dimensions;
+					std::vector<Alarm::LabelsItem> labels;
 					std::string _namespace;
 					std::string effectiveInterval;
 					std::string noDataPolicy;
 					std::string alertState;
 					std::string groupId;
-					std::string metricName;
 					Escalations escalations;
 					bool enableState;
-					CompositeExpression compositeExpression;
 					std::string webhook;
 					std::string resources;
-					std::string ruleName;
 				};
 
 

cms/include/alibabacloud/cms/model/DescribeSiteMonitorLogRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CMS_MODEL_DESCRIBESITEMONITORLOGREQUEST_H_
+#define ALIBABACLOUD_CMS_MODEL_DESCRIBESITEMONITORLOGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/cms/CmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CMS_EXPORT DescribeSiteMonitorLogRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSiteMonitorLogRequest();
+				~DescribeSiteMonitorLogRequest();
+
+				std::string getCity()const;
+				void setCity(const std::string& city);
+				std::string getIsp()const;
+				void setIsp(const std::string& isp);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getTaskIds()const;
+				void setTaskIds(const std::string& taskIds);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getMetricName()const;
+				void setMetricName(const std::string& metricName);
+				int getLength()const;
+				void setLength(int length);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getFilter()const;
+				void setFilter(const std::string& filter);
+				std::string getDimensions()const;
+				void setDimensions(const std::string& dimensions);
+
+            private:
+				std::string city_;
+				std::string isp_;
+				std::string startTime_;
+				std::string taskIds_;
+				std::string nextToken_;
+				std::string metricName_;
+				int length_;
+				std::string endTime_;
+				std::string filter_;
+				std::string dimensions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CMS_MODEL_DESCRIBESITEMONITORLOGREQUEST_H_

cms/include/alibabacloud/cms/model/DescribeSiteMonitorLogResult.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_CMS_MODEL_DESCRIBESITEMONITORLOGRESULT_H_
+#define ALIBABACLOUD_CMS_MODEL_DESCRIBESITEMONITORLOGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cms/CmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CMS_EXPORT DescribeSiteMonitorLogResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeSiteMonitorLogResult();
+				explicit DescribeSiteMonitorLogResult(const std::string &payload);
+				~DescribeSiteMonitorLogResult();
+				std::string getNextToken()const;
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				std::string getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				std::string success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CMS_MODEL_DESCRIBESITEMONITORLOGRESULT_H_

cms/include/alibabacloud/cms/model/PutEventRuleRequest.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 				struct EventPattern
 				{
 					std::vector<std::string> levelList;
+					Struct keywordFilter;
 					std::string product;
 					std::vector<std::string> statusList;
 					std::vector<std::string> nameList;

cms/include/alibabacloud/cms/model/PutResourceMetricRuleRequest.h

@@ -41,26 +41,20 @@ namespace AlibabaCloud
 				void setEscalationsWarnComparisonOperator(const std::string& escalationsWarnComparisonOperator);
 				std::string getRuleName()const;
 				void setRuleName(const std::string& ruleName);
-				std::string getEscalationsInfoStatistics()const;
-				void setEscalationsInfoStatistics(const std::string& escalationsInfoStatistics);
 				std::string getEffectiveInterval()const;
 				void setEffectiveInterval(const std::string& effectiveInterval);
-				std::string getEscalationsInfoComparisonOperator()const;
-				void setEscalationsInfoComparisonOperator(const std::string& escalationsInfoComparisonOperator);
 				std::string getNoDataPolicy()const;
 				void setNoDataPolicy(const std::string& noDataPolicy);
 				std::string getNoEffectiveInterval()const;
 				void setNoEffectiveInterval(const std::string& noEffectiveInterval);
 				std::string getEmailSubject()const;
 				void setEmailSubject(const std::string& emailSubject);
-				int getSilenceTime()const;
-				void setSilenceTime(int silenceTime);
+				std::string getOptions()const;
+				void setOptions(const std::string& options);
 				std::string getMetricName()const;
 				void setMetricName(const std::string& metricName);
 				int getEscalationsWarnTimes()const;
 				void setEscalationsWarnTimes(int escalationsWarnTimes);
-				Struct getCompositeExpression()const;
-				void setCompositeExpression(const Struct& compositeExpression);
 				std::string getPeriod()const;
 				void setPeriod(const std::string& period);
 				std::string getEscalationsWarnThreshold()const;
@@ -71,14 +65,32 @@ namespace AlibabaCloud
 				void setEscalationsCriticalStatistics(const std::string& escalationsCriticalStatistics);
 				std::string getGroupId()const;
 				void setGroupId(const std::string& groupId);
+				std::string getGroupName()const;
+				void setGroupName(const std::string& groupName);
+				Array getLabels()const;
+				void setLabels(const Array& labels);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+				std::string getRuleId()const;
+				void setRuleId(const std::string& ruleId);
+				std::string getEscalationsCriticalThreshold()const;
+				void setEscalationsCriticalThreshold(const std::string& escalationsCriticalThreshold);
+				std::string getEscalationsInfoStatistics()const;
+				void setEscalationsInfoStatistics(const std::string& escalationsInfoStatistics);
+				std::string getEscalationsInfoComparisonOperator()const;
+				void setEscalationsInfoComparisonOperator(const std::string& escalationsInfoComparisonOperator);
+				int getSilenceTime()const;
+				void setSilenceTime(int silenceTime);
+				Struct getPrometheus()const;
+				void setPrometheus(const Struct& prometheus);
+				Struct getCompositeExpression()const;
+				void setCompositeExpression(const Struct& compositeExpression);
 				std::string getResources()const;
 				void setResources(const std::string& resources);
 				int getEscalationsInfoTimes()const;
 				void setEscalationsInfoTimes(int escalationsInfoTimes);
 				std::string getGroupBy()const;
 				void setGroupBy(const std::string& groupBy);
-				std::string getGroupName()const;
-				void setGroupName(const std::string& groupName);
 				int getEscalationsCriticalTimes()const;
 				void setEscalationsCriticalTimes(int escalationsCriticalTimes);
 				std::string getEscalationsWarnStatistics()const;
@@ -87,46 +99,43 @@ namespace AlibabaCloud
 				void setEscalationsInfoThreshold(const std::string& escalationsInfoThreshold);
 				std::string get_Namespace()const;
 				void set_Namespace(const std::string& _namespace);
-				std::string getInterval()const;
-				void setInterval(const std::string& interval);
-				std::string getRuleId()const;
-				void setRuleId(const std::string& ruleId);
 				std::string getEscalationsCriticalComparisonOperator()const;
 				void setEscalationsCriticalComparisonOperator(const std::string& escalationsCriticalComparisonOperator);
-				std::string getEscalationsCriticalThreshold()const;
-				void setEscalationsCriticalThreshold(const std::string& escalationsCriticalThreshold);
 
             private:
 				std::string webhook_;
 				std::string escalationsWarnComparisonOperator_;
 				std::string ruleName_;
-				std::string escalationsInfoStatistics_;
 				std::string effectiveInterval_;
-				std::string escalationsInfoComparisonOperator_;
 				std::string noDataPolicy_;
 				std::string noEffectiveInterval_;
 				std::string emailSubject_;
-				int silenceTime_;
+				std::string options_;
 				std::string metricName_;
 				int escalationsWarnTimes_;
-				Struct compositeExpression_;
 				std::string period_;
 				std::string escalationsWarnThreshold_;
 				std::string contactGroups_;
 				std::string escalationsCriticalStatistics_;
 				std::string groupId_;
+				std::string groupName_;
+				Array labels_;
+				std::string interval_;
+				std::string ruleId_;
+				std::string escalationsCriticalThreshold_;
+				std::string escalationsInfoStatistics_;
+				std::string escalationsInfoComparisonOperator_;
+				int silenceTime_;
+				Struct prometheus_;
+				Struct compositeExpression_;
 				std::string resources_;
 				int escalationsInfoTimes_;
 				std::string groupBy_;
-				std::string groupName_;
 				int escalationsCriticalTimes_;
 				std::string escalationsWarnStatistics_;
 				std::string escalationsInfoThreshold_;
 				std::string _namespace_;
-				std::string interval_;
-				std::string ruleId_;
 				std::string escalationsCriticalComparisonOperator_;
-				std::string escalationsCriticalThreshold_;
 
 			};
 		}

cms/src/CmsClient.cc

@@ -375,6 +375,42 @@ CmsClient::CreateHostAvailabilityOutcomeCallable CmsClient::createHostAvailabili
 	return task->get_future();
 }
 
+CmsClient::CreateInstantSiteMonitorOutcome CmsClient::createInstantSiteMonitor(const CreateInstantSiteMonitorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateInstantSiteMonitorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateInstantSiteMonitorOutcome(CreateInstantSiteMonitorResult(outcome.result()));
+	else
+		return CreateInstantSiteMonitorOutcome(outcome.error());
+}
+
+void CmsClient::createInstantSiteMonitorAsync(const CreateInstantSiteMonitorRequest& request, const CreateInstantSiteMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createInstantSiteMonitor(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CmsClient::CreateInstantSiteMonitorOutcomeCallable CmsClient::createInstantSiteMonitorCallable(const CreateInstantSiteMonitorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateInstantSiteMonitorOutcome()>>(
+			[this, request]()
+			{
+			return this->createInstantSiteMonitor(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CmsClient::CreateMetricRuleResourcesOutcome CmsClient::createMetricRuleResources(const CreateMetricRuleResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3363,6 +3399,42 @@ CmsClient::DescribeSiteMonitorListOutcomeCallable CmsClient::describeSiteMonitor
 	return task->get_future();
 }
 
+CmsClient::DescribeSiteMonitorLogOutcome CmsClient::describeSiteMonitorLog(const DescribeSiteMonitorLogRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSiteMonitorLogOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSiteMonitorLogOutcome(DescribeSiteMonitorLogResult(outcome.result()));
+	else
+		return DescribeSiteMonitorLogOutcome(outcome.error());
+}
+
+void CmsClient::describeSiteMonitorLogAsync(const DescribeSiteMonitorLogRequest& request, const DescribeSiteMonitorLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSiteMonitorLog(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CmsClient::DescribeSiteMonitorLogOutcomeCallable CmsClient::describeSiteMonitorLogCallable(const DescribeSiteMonitorLogRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSiteMonitorLogOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSiteMonitorLog(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CmsClient::DescribeSiteMonitorQuotaOutcome CmsClient::describeSiteMonitorQuota(const DescribeSiteMonitorQuotaRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cms/src/model/CreateInstantSiteMonitorRequest.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/cms/model/CreateInstantSiteMonitorRequest.h>
+
+using AlibabaCloud::Cms::Model::CreateInstantSiteMonitorRequest;
+
+CreateInstantSiteMonitorRequest::CreateInstantSiteMonitorRequest() :
+	RpcServiceRequest("cms", "2019-01-01", "CreateInstantSiteMonitor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateInstantSiteMonitorRequest::~CreateInstantSiteMonitorRequest()
+{}
+
+int CreateInstantSiteMonitorRequest::getRandomIspCity()const
+{
+	return randomIspCity_;
+}
+
+void CreateInstantSiteMonitorRequest::setRandomIspCity(int randomIspCity)
+{
+	randomIspCity_ = randomIspCity;
+	setParameter("RandomIspCity", std::to_string(randomIspCity));
+}
+
+std::string CreateInstantSiteMonitorRequest::getAddress()const
+{
+	return address_;
+}
+
+void CreateInstantSiteMonitorRequest::setAddress(const std::string& address)
+{
+	address_ = address;
+	setParameter("Address", address);
+}
+
+std::string CreateInstantSiteMonitorRequest::getTaskType()const
+{
+	return taskType_;
+}
+
+void CreateInstantSiteMonitorRequest::setTaskType(const std::string& taskType)
+{
+	taskType_ = taskType;
+	setParameter("TaskType", taskType);
+}
+
+std::string CreateInstantSiteMonitorRequest::getTaskName()const
+{
+	return taskName_;
+}
+
+void CreateInstantSiteMonitorRequest::setTaskName(const std::string& taskName)
+{
+	taskName_ = taskName;
+	setParameter("TaskName", taskName);
+}
+
+std::string CreateInstantSiteMonitorRequest::getIspCities()const
+{
+	return ispCities_;
+}
+
+void CreateInstantSiteMonitorRequest::setIspCities(const std::string& ispCities)
+{
+	ispCities_ = ispCities;
+	setParameter("IspCities", ispCities);
+}
+
+std::string CreateInstantSiteMonitorRequest::getOptionsJson()const
+{
+	return optionsJson_;
+}
+
+void CreateInstantSiteMonitorRequest::setOptionsJson(const std::string& optionsJson)
+{
+	optionsJson_ = optionsJson;
+	setParameter("OptionsJson", optionsJson);
+}
+

cms/src/model/CreateInstantSiteMonitorResult.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/cms/model/CreateInstantSiteMonitorResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cms;
+using namespace AlibabaCloud::Cms::Model;
+
+CreateInstantSiteMonitorResult::CreateInstantSiteMonitorResult() :
+	ServiceResult()
+{}
+
+CreateInstantSiteMonitorResult::CreateInstantSiteMonitorResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateInstantSiteMonitorResult::~CreateInstantSiteMonitorResult()
+{}
+
+void CreateInstantSiteMonitorResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCreateResultListNode = value["CreateResultList"]["CreateResultListItem"];
+	for (auto valueCreateResultListCreateResultListItem : allCreateResultListNode)
+	{
+		CreateResultListItem createResultListObject;
+		if(!valueCreateResultListCreateResultListItem["TaskId"].isNull())
+			createResultListObject.taskId = valueCreateResultListCreateResultListItem["TaskId"].asString();
+		if(!valueCreateResultListCreateResultListItem["TaskName"].isNull())
+			createResultListObject.taskName = valueCreateResultListCreateResultListItem["TaskName"].asString();
+		createResultList_.push_back(createResultListObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString();
+
+}
+
+std::string CreateInstantSiteMonitorResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<CreateInstantSiteMonitorResult::CreateResultListItem> CreateInstantSiteMonitorResult::getCreateResultList()const
+{
+	return createResultList_;
+}
+
+std::string CreateInstantSiteMonitorResult::getCode()const
+{
+	return code_;
+}
+
+std::string CreateInstantSiteMonitorResult::getSuccess()const
+{
+	return success_;
+}
+

cms/src/model/DescribeMetricRuleListResult.cc

@@ -83,6 +83,18 @@ void DescribeMetricRuleListResult::parse(const std::string &payload)
 			alarmsObject.resources = valueAlarmsAlarm["Resources"].asString();
 		if(!valueAlarmsAlarm["NoDataPolicy"].isNull())
 			alarmsObject.noDataPolicy = valueAlarmsAlarm["NoDataPolicy"].asString();
+		if(!valueAlarmsAlarm["Options"].isNull())
+			alarmsObject.options = valueAlarmsAlarm["Options"].asString();
+		auto allLabelsNode = valueAlarmsAlarm["Labels"]["LabelsItem"];
+		for (auto valueAlarmsAlarmLabelsLabelsItem : allLabelsNode)
+		{
+			Alarm::LabelsItem labelsObject;
+			if(!valueAlarmsAlarmLabelsLabelsItem["Key"].isNull())
+				labelsObject.key = valueAlarmsAlarmLabelsLabelsItem["Key"].asString();
+			if(!valueAlarmsAlarmLabelsLabelsItem["Value"].isNull())
+				labelsObject.value = valueAlarmsAlarmLabelsLabelsItem["Value"].asString();
+			alarmsObject.labels.push_back(labelsObject);
+		}
 		auto escalationsNode = value["Escalations"];
 		auto infoNode = escalationsNode["Info"];
 		if(!infoNode["ComparisonOperator"].isNull())
@@ -144,6 +156,23 @@ void DescribeMetricRuleListResult::parse(const std::string &payload)
 				expressionListItemObject.id = compositeExpressionNodeExpressionListExpressionListItem["Id"].asString();
 			alarmsObject.compositeExpression.expressionList.push_back(expressionListItemObject);
 		}
+		auto prometheusNode = value["Prometheus"];
+		if(!prometheusNode["PromQL"].isNull())
+			alarmsObject.prometheus.promQL = prometheusNode["PromQL"].asString();
+		if(!prometheusNode["Level"].isNull())
+			alarmsObject.prometheus.level = prometheusNode["Level"].asString();
+		if(!prometheusNode["Times"].isNull())
+			alarmsObject.prometheus.times = std::stol(prometheusNode["Times"].asString());
+		auto allAnnotationsNode = prometheusNode["Annotations"]["AnnotationsItem"];
+		for (auto prometheusNodeAnnotationsAnnotationsItem : allAnnotationsNode)
+		{
+			Alarm::Prometheus::AnnotationsItem annotationsItemObject;
+			if(!prometheusNodeAnnotationsAnnotationsItem["Key"].isNull())
+				annotationsItemObject.key = prometheusNodeAnnotationsAnnotationsItem["Key"].asString();
+			if(!prometheusNodeAnnotationsAnnotationsItem["Value"].isNull())
+				annotationsItemObject.value = prometheusNodeAnnotationsAnnotationsItem["Value"].asString();
+			alarmsObject.prometheus.annotations.push_back(annotationsItemObject);
+		}
 		alarms_.push_back(alarmsObject);
 	}
 	if(!value["Code"].isNull())

cms/src/model/DescribeSiteMonitorLogRequest.cc

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/cms/model/DescribeSiteMonitorLogRequest.h>
+
+using AlibabaCloud::Cms::Model::DescribeSiteMonitorLogRequest;
+
+DescribeSiteMonitorLogRequest::DescribeSiteMonitorLogRequest() :
+	RpcServiceRequest("cms", "2019-01-01", "DescribeSiteMonitorLog")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSiteMonitorLogRequest::~DescribeSiteMonitorLogRequest()
+{}
+
+std::string DescribeSiteMonitorLogRequest::getCity()const
+{
+	return city_;
+}
+
+void DescribeSiteMonitorLogRequest::setCity(const std::string& city)
+{
+	city_ = city;
+	setParameter("City", city);
+}
+
+std::string DescribeSiteMonitorLogRequest::getIsp()const
+{
+	return isp_;
+}
+
+void DescribeSiteMonitorLogRequest::setIsp(const std::string& isp)
+{
+	isp_ = isp;
+	setParameter("Isp", isp);
+}
+
+std::string DescribeSiteMonitorLogRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeSiteMonitorLogRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeSiteMonitorLogRequest::getTaskIds()const
+{
+	return taskIds_;
+}
+
+void DescribeSiteMonitorLogRequest::setTaskIds(const std::string& taskIds)
+{
+	taskIds_ = taskIds;
+	setParameter("TaskIds", taskIds);
+}
+
+std::string DescribeSiteMonitorLogRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void DescribeSiteMonitorLogRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string DescribeSiteMonitorLogRequest::getMetricName()const
+{
+	return metricName_;
+}
+
+void DescribeSiteMonitorLogRequest::setMetricName(const std::string& metricName)
+{
+	metricName_ = metricName;
+	setParameter("MetricName", metricName);
+}
+
+int DescribeSiteMonitorLogRequest::getLength()const
+{
+	return length_;
+}
+
+void DescribeSiteMonitorLogRequest::setLength(int length)
+{
+	length_ = length;
+	setParameter("Length", std::to_string(length));
+}
+
+std::string DescribeSiteMonitorLogRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeSiteMonitorLogRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeSiteMonitorLogRequest::getFilter()const
+{
+	return filter_;
+}
+
+void DescribeSiteMonitorLogRequest::setFilter(const std::string& filter)
+{
+	filter_ = filter;
+	setParameter("Filter", filter);
+}
+
+std::string DescribeSiteMonitorLogRequest::getDimensions()const
+{
+	return dimensions_;
+}
+
+void DescribeSiteMonitorLogRequest::setDimensions(const std::string& dimensions)
+{
+	dimensions_ = dimensions;
+	setParameter("Dimensions", dimensions);
+}
+

cms/src/model/DescribeSiteMonitorLogResult.cc

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

cms/src/model/PutEventRuleRequest.cc

@@ -74,6 +74,7 @@ void PutEventRuleRequest::setEventPattern(const std::vector<EventPattern>& event
 		for(int dep2 = 0; dep2!= eventPatternObj.levelList.size(); dep2++) {
 			setParameter(eventPatternObjStr + ".LevelList."+ std::to_string(dep2), eventPatternObj.levelList.at(dep2));
 		}
+		setParameter(eventPatternObjStr + ".KeywordFilter", std::to_string(eventPatternObj.keywordFilter));
 		setParameter(eventPatternObjStr + ".Product", eventPatternObj.product);
 		for(int dep2 = 0; dep2!= eventPatternObj.statusList.size(); dep2++) {
 			setParameter(eventPatternObjStr + ".StatusList."+ std::to_string(dep2), eventPatternObj.statusList.at(dep2));

cms/src/model/PutEventRuleResult.cc

@@ -39,14 +39,14 @@ void PutEventRuleResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Success"].isNull())
-		success_ = value["Success"].asString() == "true";
 	if(!value["Code"].isNull())
 		code_ = value["Code"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["Data"].isNull())
 		data_ = value["Data"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 

cms/src/model/PutResourceMetricRuleRequest.cc

@@ -60,17 +60,6 @@ void PutResourceMetricRuleRequest::setRuleName(const std::string& ruleName)
 	setParameter("RuleName", ruleName);
 }
 
-std::string PutResourceMetricRuleRequest::getEscalationsInfoStatistics()const
-{
-	return escalationsInfoStatistics_;
-}
-
-void PutResourceMetricRuleRequest::setEscalationsInfoStatistics(const std::string& escalationsInfoStatistics)
-{
-	escalationsInfoStatistics_ = escalationsInfoStatistics;
-	setParameter("EscalationsInfoStatistics", escalationsInfoStatistics);
-}
-
 std::string PutResourceMetricRuleRequest::getEffectiveInterval()const
 {
 	return effectiveInterval_;
@@ -82,17 +71,6 @@ void PutResourceMetricRuleRequest::setEffectiveInterval(const std::string& effec
 	setParameter("EffectiveInterval", effectiveInterval);
 }
 
-std::string PutResourceMetricRuleRequest::getEscalationsInfoComparisonOperator()const
-{
-	return escalationsInfoComparisonOperator_;
-}
-
-void PutResourceMetricRuleRequest::setEscalationsInfoComparisonOperator(const std::string& escalationsInfoComparisonOperator)
-{
-	escalationsInfoComparisonOperator_ = escalationsInfoComparisonOperator;
-	setParameter("EscalationsInfoComparisonOperator", escalationsInfoComparisonOperator);
-}
-
 std::string PutResourceMetricRuleRequest::getNoDataPolicy()const
 {
 	return noDataPolicy_;
@@ -126,15 +104,15 @@ void PutResourceMetricRuleRequest::setEmailSubject(const std::string& emailSubje
 	setParameter("EmailSubject", emailSubject);
 }
 
-int PutResourceMetricRuleRequest::getSilenceTime()const
+std::string PutResourceMetricRuleRequest::getOptions()const
 {
-	return silenceTime_;
+	return options_;
 }
 
-void PutResourceMetricRuleRequest::setSilenceTime(int silenceTime)
+void PutResourceMetricRuleRequest::setOptions(const std::string& options)
 {
-	silenceTime_ = silenceTime;
-	setParameter("SilenceTime", std::to_string(silenceTime));
+	options_ = options;
+	setParameter("Options", options);
 }
 
 std::string PutResourceMetricRuleRequest::getMetricName()const
@@ -159,17 +137,6 @@ void PutResourceMetricRuleRequest::setEscalationsWarnTimes(int escalationsWarnTi
 	setParameter("EscalationsWarnTimes", std::to_string(escalationsWarnTimes));
 }
 
-Struct PutResourceMetricRuleRequest::getCompositeExpression()const
-{
-	return compositeExpression_;
-}
-
-void PutResourceMetricRuleRequest::setCompositeExpression(const Struct& compositeExpression)
-{
-	compositeExpression_ = compositeExpression;
-	setParameter("CompositeExpression", std::to_string(compositeExpression));
-}
-
 std::string PutResourceMetricRuleRequest::getPeriod()const
 {
 	return period_;
@@ -225,6 +192,116 @@ void PutResourceMetricRuleRequest::setGroupId(const std::string& groupId)
 	setParameter("GroupId", groupId);
 }
 
+std::string PutResourceMetricRuleRequest::getGroupName()const
+{
+	return groupName_;
+}
+
+void PutResourceMetricRuleRequest::setGroupName(const std::string& groupName)
+{
+	groupName_ = groupName;
+	setParameter("GroupName", groupName);
+}
+
+Array PutResourceMetricRuleRequest::getLabels()const
+{
+	return labels_;
+}
+
+void PutResourceMetricRuleRequest::setLabels(const Array& labels)
+{
+	labels_ = labels;
+	setParameter("Labels", std::to_string(labels));
+}
+
+std::string PutResourceMetricRuleRequest::getInterval()const
+{
+	return interval_;
+}
+
+void PutResourceMetricRuleRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string PutResourceMetricRuleRequest::getRuleId()const
+{
+	return ruleId_;
+}
+
+void PutResourceMetricRuleRequest::setRuleId(const std::string& ruleId)
+{
+	ruleId_ = ruleId;
+	setParameter("RuleId", ruleId);
+}
+
+std::string PutResourceMetricRuleRequest::getEscalationsCriticalThreshold()const
+{
+	return escalationsCriticalThreshold_;
+}
+
+void PutResourceMetricRuleRequest::setEscalationsCriticalThreshold(const std::string& escalationsCriticalThreshold)
+{
+	escalationsCriticalThreshold_ = escalationsCriticalThreshold;
+	setParameter("EscalationsCriticalThreshold", escalationsCriticalThreshold);
+}
+
+std::string PutResourceMetricRuleRequest::getEscalationsInfoStatistics()const
+{
+	return escalationsInfoStatistics_;
+}
+
+void PutResourceMetricRuleRequest::setEscalationsInfoStatistics(const std::string& escalationsInfoStatistics)
+{
+	escalationsInfoStatistics_ = escalationsInfoStatistics;
+	setParameter("EscalationsInfoStatistics", escalationsInfoStatistics);
+}
+
+std::string PutResourceMetricRuleRequest::getEscalationsInfoComparisonOperator()const
+{
+	return escalationsInfoComparisonOperator_;
+}
+
+void PutResourceMetricRuleRequest::setEscalationsInfoComparisonOperator(const std::string& escalationsInfoComparisonOperator)
+{
+	escalationsInfoComparisonOperator_ = escalationsInfoComparisonOperator;
+	setParameter("EscalationsInfoComparisonOperator", escalationsInfoComparisonOperator);
+}
+
+int PutResourceMetricRuleRequest::getSilenceTime()const
+{
+	return silenceTime_;
+}
+
+void PutResourceMetricRuleRequest::setSilenceTime(int silenceTime)
+{
+	silenceTime_ = silenceTime;
+	setParameter("SilenceTime", std::to_string(silenceTime));
+}
+
+Struct PutResourceMetricRuleRequest::getPrometheus()const
+{
+	return prometheus_;
+}
+
+void PutResourceMetricRuleRequest::setPrometheus(const Struct& prometheus)
+{
+	prometheus_ = prometheus;
+	setParameter("Prometheus", std::to_string(prometheus));
+}
+
+Struct PutResourceMetricRuleRequest::getCompositeExpression()const
+{
+	return compositeExpression_;
+}
+
+void PutResourceMetricRuleRequest::setCompositeExpression(const Struct& compositeExpression)
+{
+	compositeExpression_ = compositeExpression;
+	setParameter("CompositeExpression", std::to_string(compositeExpression));
+}
+
 std::string PutResourceMetricRuleRequest::getResources()const
 {
 	return resources_;
@@ -258,17 +335,6 @@ void PutResourceMetricRuleRequest::setGroupBy(const std::string& groupBy)
 	setParameter("GroupBy", groupBy);
 }
 
-std::string PutResourceMetricRuleRequest::getGroupName()const
-{
-	return groupName_;
-}
-
-void PutResourceMetricRuleRequest::setGroupName(const std::string& groupName)
-{
-	groupName_ = groupName;
-	setParameter("GroupName", groupName);
-}
-
 int PutResourceMetricRuleRequest::getEscalationsCriticalTimes()const
 {
 	return escalationsCriticalTimes_;
@@ -313,28 +379,6 @@ void PutResourceMetricRuleRequest::set_Namespace(const std::string& _namespace)
 	setParameter("_Namespace", _namespace);
 }
 
-std::string PutResourceMetricRuleRequest::getInterval()const
-{
-	return interval_;
-}
-
-void PutResourceMetricRuleRequest::setInterval(const std::string& interval)
-{
-	interval_ = interval;
-	setParameter("Interval", interval);
-}
-
-std::string PutResourceMetricRuleRequest::getRuleId()const
-{
-	return ruleId_;
-}
-
-void PutResourceMetricRuleRequest::setRuleId(const std::string& ruleId)
-{
-	ruleId_ = ruleId;
-	setParameter("RuleId", ruleId);
-}
-
 std::string PutResourceMetricRuleRequest::getEscalationsCriticalComparisonOperator()const
 {
 	return escalationsCriticalComparisonOperator_;
@@ -346,14 +390,3 @@ void PutResourceMetricRuleRequest::setEscalationsCriticalComparisonOperator(cons
 	setParameter("EscalationsCriticalComparisonOperator", escalationsCriticalComparisonOperator);
 }
 
-std::string PutResourceMetricRuleRequest::getEscalationsCriticalThreshold()const
-{
-	return escalationsCriticalThreshold_;
-}
-
-void PutResourceMetricRuleRequest::setEscalationsCriticalThreshold(const std::string& escalationsCriticalThreshold)
-{
-	escalationsCriticalThreshold_ = escalationsCriticalThreshold;
-	setParameter("EscalationsCriticalThreshold", escalationsCriticalThreshold);
-}
-

config/CMakeLists.txt

@@ -21,101 +21,269 @@ set(config_public_header
 	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/ActiveAggregateConfigRulesRequest.h
+	include/alibabacloud/config/model/ActiveAggregateConfigRulesResult.h
+	include/alibabacloud/config/model/AttachAggregateConfigRuleToCompliancePackRequest.h
+	include/alibabacloud/config/model/AttachAggregateConfigRuleToCompliancePackResult.h
+	include/alibabacloud/config/model/AttachConfigRuleToCompliancePackRequest.h
+	include/alibabacloud/config/model/AttachConfigRuleToCompliancePackResult.h
+	include/alibabacloud/config/model/CreateAggregateCompliancePackRequest.h
+	include/alibabacloud/config/model/CreateAggregateCompliancePackResult.h
+	include/alibabacloud/config/model/CreateAggregateConfigRuleRequest.h
+	include/alibabacloud/config/model/CreateAggregateConfigRuleResult.h
+	include/alibabacloud/config/model/CreateAggregatorRequest.h
+	include/alibabacloud/config/model/CreateAggregatorResult.h
+	include/alibabacloud/config/model/CreateCompliancePackRequest.h
+	include/alibabacloud/config/model/CreateCompliancePackResult.h
+	include/alibabacloud/config/model/CreateConfigRuleRequest.h
+	include/alibabacloud/config/model/CreateConfigRuleResult.h
+	include/alibabacloud/config/model/DeactiveAggregateConfigRulesRequest.h
+	include/alibabacloud/config/model/DeactiveAggregateConfigRulesResult.h
+	include/alibabacloud/config/model/DeactiveConfigRulesRequest.h
+	include/alibabacloud/config/model/DeactiveConfigRulesResult.h
+	include/alibabacloud/config/model/DeleteAggregateCompliancePacksRequest.h
+	include/alibabacloud/config/model/DeleteAggregateCompliancePacksResult.h
+	include/alibabacloud/config/model/DeleteAggregateConfigRulesRequest.h
+	include/alibabacloud/config/model/DeleteAggregateConfigRulesResult.h
+	include/alibabacloud/config/model/DeleteAggregatorsRequest.h
+	include/alibabacloud/config/model/DeleteAggregatorsResult.h
+	include/alibabacloud/config/model/DeleteCompliancePacksRequest.h
+	include/alibabacloud/config/model/DeleteCompliancePacksResult.h
+	include/alibabacloud/config/model/DetachAggregateConfigRuleToCompliancePackRequest.h
+	include/alibabacloud/config/model/DetachAggregateConfigRuleToCompliancePackResult.h
+	include/alibabacloud/config/model/DetachConfigRuleToCompliancePackRequest.h
+	include/alibabacloud/config/model/DetachConfigRuleToCompliancePackResult.h
+	include/alibabacloud/config/model/GenerateAggregateCompliancePackReportRequest.h
+	include/alibabacloud/config/model/GenerateAggregateCompliancePackReportResult.h
+	include/alibabacloud/config/model/GenerateAggregateConfigRulesReportRequest.h
+	include/alibabacloud/config/model/GenerateAggregateConfigRulesReportResult.h
+	include/alibabacloud/config/model/GenerateCompliancePackReportRequest.h
+	include/alibabacloud/config/model/GenerateCompliancePackReportResult.h
+	include/alibabacloud/config/model/GenerateConfigRulesReportRequest.h
+	include/alibabacloud/config/model/GenerateConfigRulesReportResult.h
+	include/alibabacloud/config/model/GetAggregateAccountComplianceByPackRequest.h
+	include/alibabacloud/config/model/GetAggregateAccountComplianceByPackResult.h
+	include/alibabacloud/config/model/GetAggregateCompliancePackRequest.h
+	include/alibabacloud/config/model/GetAggregateCompliancePackResult.h
+	include/alibabacloud/config/model/GetAggregateCompliancePackReportRequest.h
+	include/alibabacloud/config/model/GetAggregateCompliancePackReportResult.h
+	include/alibabacloud/config/model/GetAggregateConfigRuleRequest.h
+	include/alibabacloud/config/model/GetAggregateConfigRuleResult.h
+	include/alibabacloud/config/model/GetAggregateConfigRuleComplianceByPackRequest.h
+	include/alibabacloud/config/model/GetAggregateConfigRuleComplianceByPackResult.h
+	include/alibabacloud/config/model/GetAggregateConfigRuleSummaryByRiskLevelRequest.h
+	include/alibabacloud/config/model/GetAggregateConfigRuleSummaryByRiskLevelResult.h
+	include/alibabacloud/config/model/GetAggregateConfigRulesReportRequest.h
+	include/alibabacloud/config/model/GetAggregateConfigRulesReportResult.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceByConfigRuleRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceByConfigRuleResult.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceByPackRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceByPackResult.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceTimelineRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceComplianceTimelineResult.h
+	include/alibabacloud/config/model/GetAggregateResourceConfigurationTimelineRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceConfigurationTimelineResult.h
+	include/alibabacloud/config/model/GetAggregateResourceCountsGroupByRegionRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceCountsGroupByRegionResult.h
+	include/alibabacloud/config/model/GetAggregateResourceCountsGroupByResourceTypeRequest.h
+	include/alibabacloud/config/model/GetAggregateResourceCountsGroupByResourceTypeResult.h
+	include/alibabacloud/config/model/GetAggregatorRequest.h
+	include/alibabacloud/config/model/GetAggregatorResult.h
+	include/alibabacloud/config/model/GetCompliancePackRequest.h
+	include/alibabacloud/config/model/GetCompliancePackResult.h
+	include/alibabacloud/config/model/GetCompliancePackReportRequest.h
+	include/alibabacloud/config/model/GetCompliancePackReportResult.h
+	include/alibabacloud/config/model/GetConfigRuleRequest.h
+	include/alibabacloud/config/model/GetConfigRuleResult.h
+	include/alibabacloud/config/model/GetConfigRuleComplianceByPackRequest.h
+	include/alibabacloud/config/model/GetConfigRuleComplianceByPackResult.h
+	include/alibabacloud/config/model/GetConfigRuleSummaryByRiskLevelRequest.h
+	include/alibabacloud/config/model/GetConfigRuleSummaryByRiskLevelResult.h
+	include/alibabacloud/config/model/GetConfigRulesReportRequest.h
+	include/alibabacloud/config/model/GetConfigRulesReportResult.h
+	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByRegionRequest.h
+	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByRegionResult.h
+	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.h
+	include/alibabacloud/config/model/GetDiscoveredResourceCountsGroupByResourceTypeResult.h
+	include/alibabacloud/config/model/GetResourceComplianceByConfigRuleRequest.h
+	include/alibabacloud/config/model/GetResourceComplianceByConfigRuleResult.h
+	include/alibabacloud/config/model/GetResourceComplianceByPackRequest.h
+	include/alibabacloud/config/model/GetResourceComplianceByPackResult.h
 	include/alibabacloud/config/model/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 )
+	include/alibabacloud/config/model/IgnoreAggregateEvaluationResultsRequest.h
+	include/alibabacloud/config/model/IgnoreAggregateEvaluationResultsResult.h
+	include/alibabacloud/config/model/IgnoreEvaluationResultsRequest.h
+	include/alibabacloud/config/model/IgnoreEvaluationResultsResult.h
+	include/alibabacloud/config/model/ListAggregateCompliancePacksRequest.h
+	include/alibabacloud/config/model/ListAggregateCompliancePacksResult.h
+	include/alibabacloud/config/model/ListAggregateConfigRuleEvaluationResultsRequest.h
+	include/alibabacloud/config/model/ListAggregateConfigRuleEvaluationResultsResult.h
+	include/alibabacloud/config/model/ListAggregateConfigRulesRequest.h
+	include/alibabacloud/config/model/ListAggregateConfigRulesResult.h
+	include/alibabacloud/config/model/ListAggregateResourceEvaluationResultsRequest.h
+	include/alibabacloud/config/model/ListAggregateResourceEvaluationResultsResult.h
+	include/alibabacloud/config/model/ListAggregatorsRequest.h
+	include/alibabacloud/config/model/ListAggregatorsResult.h
+	include/alibabacloud/config/model/ListCompliancePackTemplatesRequest.h
+	include/alibabacloud/config/model/ListCompliancePackTemplatesResult.h
+	include/alibabacloud/config/model/ListCompliancePacksRequest.h
+	include/alibabacloud/config/model/ListCompliancePacksResult.h
+	include/alibabacloud/config/model/ListConfigRuleEvaluationResultsRequest.h
+	include/alibabacloud/config/model/ListConfigRuleEvaluationResultsResult.h
+	include/alibabacloud/config/model/ListResourceEvaluationResultsRequest.h
+	include/alibabacloud/config/model/ListResourceEvaluationResultsResult.h
+	include/alibabacloud/config/model/RevertAggregateEvaluationResultsRequest.h
+	include/alibabacloud/config/model/RevertAggregateEvaluationResultsResult.h
+	include/alibabacloud/config/model/RevertEvaluationResultsRequest.h
+	include/alibabacloud/config/model/RevertEvaluationResultsResult.h
+	include/alibabacloud/config/model/StartAggregateConfigRuleEvaluationRequest.h
+	include/alibabacloud/config/model/StartAggregateConfigRuleEvaluationResult.h
+	include/alibabacloud/config/model/UpdateAggregateCompliancePackRequest.h
+	include/alibabacloud/config/model/UpdateAggregateCompliancePackResult.h
+	include/alibabacloud/config/model/UpdateAggregateConfigRuleRequest.h
+	include/alibabacloud/config/model/UpdateAggregateConfigRuleResult.h
+	include/alibabacloud/config/model/UpdateAggregatorRequest.h
+	include/alibabacloud/config/model/UpdateAggregatorResult.h
+	include/alibabacloud/config/model/UpdateCompliancePackRequest.h
+	include/alibabacloud/config/model/UpdateCompliancePackResult.h
+	include/alibabacloud/config/model/UpdateConfigRuleRequest.h
+	include/alibabacloud/config/model/UpdateConfigRuleResult.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/ActiveAggregateConfigRulesRequest.cc
+	src/model/ActiveAggregateConfigRulesResult.cc
+	src/model/AttachAggregateConfigRuleToCompliancePackRequest.cc
+	src/model/AttachAggregateConfigRuleToCompliancePackResult.cc
+	src/model/AttachConfigRuleToCompliancePackRequest.cc
+	src/model/AttachConfigRuleToCompliancePackResult.cc
+	src/model/CreateAggregateCompliancePackRequest.cc
+	src/model/CreateAggregateCompliancePackResult.cc
+	src/model/CreateAggregateConfigRuleRequest.cc
+	src/model/CreateAggregateConfigRuleResult.cc
+	src/model/CreateAggregatorRequest.cc
+	src/model/CreateAggregatorResult.cc
+	src/model/CreateCompliancePackRequest.cc
+	src/model/CreateCompliancePackResult.cc
+	src/model/CreateConfigRuleRequest.cc
+	src/model/CreateConfigRuleResult.cc
+	src/model/DeactiveAggregateConfigRulesRequest.cc
+	src/model/DeactiveAggregateConfigRulesResult.cc
+	src/model/DeactiveConfigRulesRequest.cc
+	src/model/DeactiveConfigRulesResult.cc
+	src/model/DeleteAggregateCompliancePacksRequest.cc
+	src/model/DeleteAggregateCompliancePacksResult.cc
+	src/model/DeleteAggregateConfigRulesRequest.cc
+	src/model/DeleteAggregateConfigRulesResult.cc
+	src/model/DeleteAggregatorsRequest.cc
+	src/model/DeleteAggregatorsResult.cc
+	src/model/DeleteCompliancePacksRequest.cc
+	src/model/DeleteCompliancePacksResult.cc
+	src/model/DetachAggregateConfigRuleToCompliancePackRequest.cc
+	src/model/DetachAggregateConfigRuleToCompliancePackResult.cc
+	src/model/DetachConfigRuleToCompliancePackRequest.cc
+	src/model/DetachConfigRuleToCompliancePackResult.cc
+	src/model/GenerateAggregateCompliancePackReportRequest.cc
+	src/model/GenerateAggregateCompliancePackReportResult.cc
+	src/model/GenerateAggregateConfigRulesReportRequest.cc
+	src/model/GenerateAggregateConfigRulesReportResult.cc
+	src/model/GenerateCompliancePackReportRequest.cc
+	src/model/GenerateCompliancePackReportResult.cc
+	src/model/GenerateConfigRulesReportRequest.cc
+	src/model/GenerateConfigRulesReportResult.cc
+	src/model/GetAggregateAccountComplianceByPackRequest.cc
+	src/model/GetAggregateAccountComplianceByPackResult.cc
+	src/model/GetAggregateCompliancePackRequest.cc
+	src/model/GetAggregateCompliancePackResult.cc
+	src/model/GetAggregateCompliancePackReportRequest.cc
+	src/model/GetAggregateCompliancePackReportResult.cc
+	src/model/GetAggregateConfigRuleRequest.cc
+	src/model/GetAggregateConfigRuleResult.cc
+	src/model/GetAggregateConfigRuleComplianceByPackRequest.cc
+	src/model/GetAggregateConfigRuleComplianceByPackResult.cc
+	src/model/GetAggregateConfigRuleSummaryByRiskLevelRequest.cc
+	src/model/GetAggregateConfigRuleSummaryByRiskLevelResult.cc
+	src/model/GetAggregateConfigRulesReportRequest.cc
+	src/model/GetAggregateConfigRulesReportResult.cc
+	src/model/GetAggregateResourceComplianceByConfigRuleRequest.cc
+	src/model/GetAggregateResourceComplianceByConfigRuleResult.cc
+	src/model/GetAggregateResourceComplianceByPackRequest.cc
+	src/model/GetAggregateResourceComplianceByPackResult.cc
+	src/model/GetAggregateResourceComplianceTimelineRequest.cc
+	src/model/GetAggregateResourceComplianceTimelineResult.cc
+	src/model/GetAggregateResourceConfigurationTimelineRequest.cc
+	src/model/GetAggregateResourceConfigurationTimelineResult.cc
+	src/model/GetAggregateResourceCountsGroupByRegionRequest.cc
+	src/model/GetAggregateResourceCountsGroupByRegionResult.cc
+	src/model/GetAggregateResourceCountsGroupByResourceTypeRequest.cc
+	src/model/GetAggregateResourceCountsGroupByResourceTypeResult.cc
+	src/model/GetAggregatorRequest.cc
+	src/model/GetAggregatorResult.cc
+	src/model/GetCompliancePackRequest.cc
+	src/model/GetCompliancePackResult.cc
+	src/model/GetCompliancePackReportRequest.cc
+	src/model/GetCompliancePackReportResult.cc
+	src/model/GetConfigRuleRequest.cc
+	src/model/GetConfigRuleResult.cc
+	src/model/GetConfigRuleComplianceByPackRequest.cc
+	src/model/GetConfigRuleComplianceByPackResult.cc
+	src/model/GetConfigRuleSummaryByRiskLevelRequest.cc
+	src/model/GetConfigRuleSummaryByRiskLevelResult.cc
+	src/model/GetConfigRulesReportRequest.cc
+	src/model/GetConfigRulesReportResult.cc
+	src/model/GetDiscoveredResourceCountsGroupByRegionRequest.cc
+	src/model/GetDiscoveredResourceCountsGroupByRegionResult.cc
+	src/model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.cc
+	src/model/GetDiscoveredResourceCountsGroupByResourceTypeResult.cc
+	src/model/GetResourceComplianceByConfigRuleRequest.cc
+	src/model/GetResourceComplianceByConfigRuleResult.cc
+	src/model/GetResourceComplianceByPackRequest.cc
+	src/model/GetResourceComplianceByPackResult.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 )
+	src/model/IgnoreAggregateEvaluationResultsRequest.cc
+	src/model/IgnoreAggregateEvaluationResultsResult.cc
+	src/model/IgnoreEvaluationResultsRequest.cc
+	src/model/IgnoreEvaluationResultsResult.cc
+	src/model/ListAggregateCompliancePacksRequest.cc
+	src/model/ListAggregateCompliancePacksResult.cc
+	src/model/ListAggregateConfigRuleEvaluationResultsRequest.cc
+	src/model/ListAggregateConfigRuleEvaluationResultsResult.cc
+	src/model/ListAggregateConfigRulesRequest.cc
+	src/model/ListAggregateConfigRulesResult.cc
+	src/model/ListAggregateResourceEvaluationResultsRequest.cc
+	src/model/ListAggregateResourceEvaluationResultsResult.cc
+	src/model/ListAggregatorsRequest.cc
+	src/model/ListAggregatorsResult.cc
+	src/model/ListCompliancePackTemplatesRequest.cc
+	src/model/ListCompliancePackTemplatesResult.cc
+	src/model/ListCompliancePacksRequest.cc
+	src/model/ListCompliancePacksResult.cc
+	src/model/ListConfigRuleEvaluationResultsRequest.cc
+	src/model/ListConfigRuleEvaluationResultsResult.cc
+	src/model/ListResourceEvaluationResultsRequest.cc
+	src/model/ListResourceEvaluationResultsResult.cc
+	src/model/RevertAggregateEvaluationResultsRequest.cc
+	src/model/RevertAggregateEvaluationResultsResult.cc
+	src/model/RevertEvaluationResultsRequest.cc
+	src/model/RevertEvaluationResultsResult.cc
+	src/model/StartAggregateConfigRuleEvaluationRequest.cc
+	src/model/StartAggregateConfigRuleEvaluationResult.cc
+	src/model/UpdateAggregateCompliancePackRequest.cc
+	src/model/UpdateAggregateCompliancePackResult.cc
+	src/model/UpdateAggregateConfigRuleRequest.cc
+	src/model/UpdateAggregateConfigRuleResult.cc
+	src/model/UpdateAggregatorRequest.cc
+	src/model/UpdateAggregatorResult.cc
+	src/model/UpdateCompliancePackRequest.cc
+	src/model/UpdateCompliancePackResult.cc
+	src/model/UpdateConfigRuleRequest.cc
+	src/model/UpdateConfigRuleResult.cc )
 
 add_library(config ${LIB_TYPE}
 	${config_public_header}

config/include/alibabacloud/config/ConfigClient.h

@@ -22,52 +22,136 @@
 #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/ActiveAggregateConfigRulesRequest.h"
+#include "model/ActiveAggregateConfigRulesResult.h"
+#include "model/AttachAggregateConfigRuleToCompliancePackRequest.h"
+#include "model/AttachAggregateConfigRuleToCompliancePackResult.h"
+#include "model/AttachConfigRuleToCompliancePackRequest.h"
+#include "model/AttachConfigRuleToCompliancePackResult.h"
+#include "model/CreateAggregateCompliancePackRequest.h"
+#include "model/CreateAggregateCompliancePackResult.h"
+#include "model/CreateAggregateConfigRuleRequest.h"
+#include "model/CreateAggregateConfigRuleResult.h"
+#include "model/CreateAggregatorRequest.h"
+#include "model/CreateAggregatorResult.h"
+#include "model/CreateCompliancePackRequest.h"
+#include "model/CreateCompliancePackResult.h"
+#include "model/CreateConfigRuleRequest.h"
+#include "model/CreateConfigRuleResult.h"
+#include "model/DeactiveAggregateConfigRulesRequest.h"
+#include "model/DeactiveAggregateConfigRulesResult.h"
+#include "model/DeactiveConfigRulesRequest.h"
+#include "model/DeactiveConfigRulesResult.h"
+#include "model/DeleteAggregateCompliancePacksRequest.h"
+#include "model/DeleteAggregateCompliancePacksResult.h"
+#include "model/DeleteAggregateConfigRulesRequest.h"
+#include "model/DeleteAggregateConfigRulesResult.h"
+#include "model/DeleteAggregatorsRequest.h"
+#include "model/DeleteAggregatorsResult.h"
+#include "model/DeleteCompliancePacksRequest.h"
+#include "model/DeleteCompliancePacksResult.h"
+#include "model/DetachAggregateConfigRuleToCompliancePackRequest.h"
+#include "model/DetachAggregateConfigRuleToCompliancePackResult.h"
+#include "model/DetachConfigRuleToCompliancePackRequest.h"
+#include "model/DetachConfigRuleToCompliancePackResult.h"
+#include "model/GenerateAggregateCompliancePackReportRequest.h"
+#include "model/GenerateAggregateCompliancePackReportResult.h"
+#include "model/GenerateAggregateConfigRulesReportRequest.h"
+#include "model/GenerateAggregateConfigRulesReportResult.h"
+#include "model/GenerateCompliancePackReportRequest.h"
+#include "model/GenerateCompliancePackReportResult.h"
+#include "model/GenerateConfigRulesReportRequest.h"
+#include "model/GenerateConfigRulesReportResult.h"
+#include "model/GetAggregateAccountComplianceByPackRequest.h"
+#include "model/GetAggregateAccountComplianceByPackResult.h"
+#include "model/GetAggregateCompliancePackRequest.h"
+#include "model/GetAggregateCompliancePackResult.h"
+#include "model/GetAggregateCompliancePackReportRequest.h"
+#include "model/GetAggregateCompliancePackReportResult.h"
+#include "model/GetAggregateConfigRuleRequest.h"
+#include "model/GetAggregateConfigRuleResult.h"
+#include "model/GetAggregateConfigRuleComplianceByPackRequest.h"
+#include "model/GetAggregateConfigRuleComplianceByPackResult.h"
+#include "model/GetAggregateConfigRuleSummaryByRiskLevelRequest.h"
+#include "model/GetAggregateConfigRuleSummaryByRiskLevelResult.h"
+#include "model/GetAggregateConfigRulesReportRequest.h"
+#include "model/GetAggregateConfigRulesReportResult.h"
+#include "model/GetAggregateResourceComplianceByConfigRuleRequest.h"
+#include "model/GetAggregateResourceComplianceByConfigRuleResult.h"
+#include "model/GetAggregateResourceComplianceByPackRequest.h"
+#include "model/GetAggregateResourceComplianceByPackResult.h"
+#include "model/GetAggregateResourceComplianceTimelineRequest.h"
+#include "model/GetAggregateResourceComplianceTimelineResult.h"
+#include "model/GetAggregateResourceConfigurationTimelineRequest.h"
+#include "model/GetAggregateResourceConfigurationTimelineResult.h"
+#include "model/GetAggregateResourceCountsGroupByRegionRequest.h"
+#include "model/GetAggregateResourceCountsGroupByRegionResult.h"
+#include "model/GetAggregateResourceCountsGroupByResourceTypeRequest.h"
+#include "model/GetAggregateResourceCountsGroupByResourceTypeResult.h"
+#include "model/GetAggregatorRequest.h"
+#include "model/GetAggregatorResult.h"
+#include "model/GetCompliancePackRequest.h"
+#include "model/GetCompliancePackResult.h"
+#include "model/GetCompliancePackReportRequest.h"
+#include "model/GetCompliancePackReportResult.h"
+#include "model/GetConfigRuleRequest.h"
+#include "model/GetConfigRuleResult.h"
+#include "model/GetConfigRuleComplianceByPackRequest.h"
+#include "model/GetConfigRuleComplianceByPackResult.h"
+#include "model/GetConfigRuleSummaryByRiskLevelRequest.h"
+#include "model/GetConfigRuleSummaryByRiskLevelResult.h"
+#include "model/GetConfigRulesReportRequest.h"
+#include "model/GetConfigRulesReportResult.h"
+#include "model/GetDiscoveredResourceCountsGroupByRegionRequest.h"
+#include "model/GetDiscoveredResourceCountsGroupByRegionResult.h"
+#include "model/GetDiscoveredResourceCountsGroupByResourceTypeRequest.h"
+#include "model/GetDiscoveredResourceCountsGroupByResourceTypeResult.h"
+#include "model/GetResourceComplianceByConfigRuleRequest.h"
+#include "model/GetResourceComplianceByConfigRuleResult.h"
+#include "model/GetResourceComplianceByPackRequest.h"
+#include "model/GetResourceComplianceByPackResult.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"
+#include "model/IgnoreAggregateEvaluationResultsRequest.h"
+#include "model/IgnoreAggregateEvaluationResultsResult.h"
+#include "model/IgnoreEvaluationResultsRequest.h"
+#include "model/IgnoreEvaluationResultsResult.h"
+#include "model/ListAggregateCompliancePacksRequest.h"
+#include "model/ListAggregateCompliancePacksResult.h"
+#include "model/ListAggregateConfigRuleEvaluationResultsRequest.h"
+#include "model/ListAggregateConfigRuleEvaluationResultsResult.h"
+#include "model/ListAggregateConfigRulesRequest.h"
+#include "model/ListAggregateConfigRulesResult.h"
+#include "model/ListAggregateResourceEvaluationResultsRequest.h"
+#include "model/ListAggregateResourceEvaluationResultsResult.h"
+#include "model/ListAggregatorsRequest.h"
+#include "model/ListAggregatorsResult.h"
+#include "model/ListCompliancePackTemplatesRequest.h"
+#include "model/ListCompliancePackTemplatesResult.h"
+#include "model/ListCompliancePacksRequest.h"
+#include "model/ListCompliancePacksResult.h"
+#include "model/ListConfigRuleEvaluationResultsRequest.h"
+#include "model/ListConfigRuleEvaluationResultsResult.h"
+#include "model/ListResourceEvaluationResultsRequest.h"
+#include "model/ListResourceEvaluationResultsResult.h"
+#include "model/RevertAggregateEvaluationResultsRequest.h"
+#include "model/RevertAggregateEvaluationResultsResult.h"
+#include "model/RevertEvaluationResultsRequest.h"
+#include "model/RevertEvaluationResultsResult.h"
+#include "model/StartAggregateConfigRuleEvaluationRequest.h"
+#include "model/StartAggregateConfigRuleEvaluationResult.h"
+#include "model/UpdateAggregateCompliancePackRequest.h"
+#include "model/UpdateAggregateCompliancePackResult.h"
+#include "model/UpdateAggregateConfigRuleRequest.h"
+#include "model/UpdateAggregateConfigRuleResult.h"
+#include "model/UpdateAggregatorRequest.h"
+#include "model/UpdateAggregatorResult.h"
+#include "model/UpdateCompliancePackRequest.h"
+#include "model/UpdateCompliancePackResult.h"
+#include "model/UpdateConfigRuleRequest.h"
+#include "model/UpdateConfigRuleResult.h"
 
 
 namespace AlibabaCloud
@@ -77,149 +161,401 @@ namespace AlibabaCloud
 		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::ActiveAggregateConfigRulesResult> ActiveAggregateConfigRulesOutcome;
+			typedef std::future<ActiveAggregateConfigRulesOutcome> ActiveAggregateConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ActiveAggregateConfigRulesRequest&, const ActiveAggregateConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActiveAggregateConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::AttachAggregateConfigRuleToCompliancePackResult> AttachAggregateConfigRuleToCompliancePackOutcome;
+			typedef std::future<AttachAggregateConfigRuleToCompliancePackOutcome> AttachAggregateConfigRuleToCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::AttachAggregateConfigRuleToCompliancePackRequest&, const AttachAggregateConfigRuleToCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachAggregateConfigRuleToCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::AttachConfigRuleToCompliancePackResult> AttachConfigRuleToCompliancePackOutcome;
+			typedef std::future<AttachConfigRuleToCompliancePackOutcome> AttachConfigRuleToCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::AttachConfigRuleToCompliancePackRequest&, const AttachConfigRuleToCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachConfigRuleToCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::CreateAggregateCompliancePackResult> CreateAggregateCompliancePackOutcome;
+			typedef std::future<CreateAggregateCompliancePackOutcome> CreateAggregateCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::CreateAggregateCompliancePackRequest&, const CreateAggregateCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAggregateCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::CreateAggregateConfigRuleResult> CreateAggregateConfigRuleOutcome;
+			typedef std::future<CreateAggregateConfigRuleOutcome> CreateAggregateConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::CreateAggregateConfigRuleRequest&, const CreateAggregateConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAggregateConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateAggregatorResult> CreateAggregatorOutcome;
+			typedef std::future<CreateAggregatorOutcome> CreateAggregatorOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::CreateAggregatorRequest&, const CreateAggregatorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAggregatorAsyncHandler;
+			typedef Outcome<Error, Model::CreateCompliancePackResult> CreateCompliancePackOutcome;
+			typedef std::future<CreateCompliancePackOutcome> CreateCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::CreateCompliancePackRequest&, const CreateCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::CreateConfigRuleResult> CreateConfigRuleOutcome;
+			typedef std::future<CreateConfigRuleOutcome> CreateConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::CreateConfigRuleRequest&, const CreateConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeactiveAggregateConfigRulesResult> DeactiveAggregateConfigRulesOutcome;
+			typedef std::future<DeactiveAggregateConfigRulesOutcome> DeactiveAggregateConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeactiveAggregateConfigRulesRequest&, const DeactiveAggregateConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeactiveAggregateConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::DeactiveConfigRulesResult> DeactiveConfigRulesOutcome;
+			typedef std::future<DeactiveConfigRulesOutcome> DeactiveConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeactiveConfigRulesRequest&, const DeactiveConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeactiveConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAggregateCompliancePacksResult> DeleteAggregateCompliancePacksOutcome;
+			typedef std::future<DeleteAggregateCompliancePacksOutcome> DeleteAggregateCompliancePacksOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeleteAggregateCompliancePacksRequest&, const DeleteAggregateCompliancePacksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAggregateCompliancePacksAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAggregateConfigRulesResult> DeleteAggregateConfigRulesOutcome;
+			typedef std::future<DeleteAggregateConfigRulesOutcome> DeleteAggregateConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeleteAggregateConfigRulesRequest&, const DeleteAggregateConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAggregateConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAggregatorsResult> DeleteAggregatorsOutcome;
+			typedef std::future<DeleteAggregatorsOutcome> DeleteAggregatorsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeleteAggregatorsRequest&, const DeleteAggregatorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAggregatorsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCompliancePacksResult> DeleteCompliancePacksOutcome;
+			typedef std::future<DeleteCompliancePacksOutcome> DeleteCompliancePacksOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DeleteCompliancePacksRequest&, const DeleteCompliancePacksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCompliancePacksAsyncHandler;
+			typedef Outcome<Error, Model::DetachAggregateConfigRuleToCompliancePackResult> DetachAggregateConfigRuleToCompliancePackOutcome;
+			typedef std::future<DetachAggregateConfigRuleToCompliancePackOutcome> DetachAggregateConfigRuleToCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DetachAggregateConfigRuleToCompliancePackRequest&, const DetachAggregateConfigRuleToCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachAggregateConfigRuleToCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::DetachConfigRuleToCompliancePackResult> DetachConfigRuleToCompliancePackOutcome;
+			typedef std::future<DetachConfigRuleToCompliancePackOutcome> DetachConfigRuleToCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::DetachConfigRuleToCompliancePackRequest&, const DetachConfigRuleToCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachConfigRuleToCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::GenerateAggregateCompliancePackReportResult> GenerateAggregateCompliancePackReportOutcome;
+			typedef std::future<GenerateAggregateCompliancePackReportOutcome> GenerateAggregateCompliancePackReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GenerateAggregateCompliancePackReportRequest&, const GenerateAggregateCompliancePackReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateAggregateCompliancePackReportAsyncHandler;
+			typedef Outcome<Error, Model::GenerateAggregateConfigRulesReportResult> GenerateAggregateConfigRulesReportOutcome;
+			typedef std::future<GenerateAggregateConfigRulesReportOutcome> GenerateAggregateConfigRulesReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GenerateAggregateConfigRulesReportRequest&, const GenerateAggregateConfigRulesReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateAggregateConfigRulesReportAsyncHandler;
+			typedef Outcome<Error, Model::GenerateCompliancePackReportResult> GenerateCompliancePackReportOutcome;
+			typedef std::future<GenerateCompliancePackReportOutcome> GenerateCompliancePackReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GenerateCompliancePackReportRequest&, const GenerateCompliancePackReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateCompliancePackReportAsyncHandler;
+			typedef Outcome<Error, Model::GenerateConfigRulesReportResult> GenerateConfigRulesReportOutcome;
+			typedef std::future<GenerateConfigRulesReportOutcome> GenerateConfigRulesReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GenerateConfigRulesReportRequest&, const GenerateConfigRulesReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateConfigRulesReportAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateAccountComplianceByPackResult> GetAggregateAccountComplianceByPackOutcome;
+			typedef std::future<GetAggregateAccountComplianceByPackOutcome> GetAggregateAccountComplianceByPackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateAccountComplianceByPackRequest&, const GetAggregateAccountComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateAccountComplianceByPackAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateCompliancePackResult> GetAggregateCompliancePackOutcome;
+			typedef std::future<GetAggregateCompliancePackOutcome> GetAggregateCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateCompliancePackRequest&, const GetAggregateCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateCompliancePackReportResult> GetAggregateCompliancePackReportOutcome;
+			typedef std::future<GetAggregateCompliancePackReportOutcome> GetAggregateCompliancePackReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateCompliancePackReportRequest&, const GetAggregateCompliancePackReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateCompliancePackReportAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateConfigRuleResult> GetAggregateConfigRuleOutcome;
+			typedef std::future<GetAggregateConfigRuleOutcome> GetAggregateConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateConfigRuleRequest&, const GetAggregateConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateConfigRuleComplianceByPackResult> GetAggregateConfigRuleComplianceByPackOutcome;
+			typedef std::future<GetAggregateConfigRuleComplianceByPackOutcome> GetAggregateConfigRuleComplianceByPackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateConfigRuleComplianceByPackRequest&, const GetAggregateConfigRuleComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateConfigRuleComplianceByPackAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateConfigRuleSummaryByRiskLevelResult> GetAggregateConfigRuleSummaryByRiskLevelOutcome;
+			typedef std::future<GetAggregateConfigRuleSummaryByRiskLevelOutcome> GetAggregateConfigRuleSummaryByRiskLevelOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateConfigRuleSummaryByRiskLevelRequest&, const GetAggregateConfigRuleSummaryByRiskLevelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateConfigRuleSummaryByRiskLevelAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateConfigRulesReportResult> GetAggregateConfigRulesReportOutcome;
+			typedef std::future<GetAggregateConfigRulesReportOutcome> GetAggregateConfigRulesReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateConfigRulesReportRequest&, const GetAggregateConfigRulesReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateConfigRulesReportAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceComplianceByConfigRuleResult> GetAggregateResourceComplianceByConfigRuleOutcome;
+			typedef std::future<GetAggregateResourceComplianceByConfigRuleOutcome> GetAggregateResourceComplianceByConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceByConfigRuleRequest&, const GetAggregateResourceComplianceByConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceByConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceComplianceByPackResult> GetAggregateResourceComplianceByPackOutcome;
+			typedef std::future<GetAggregateResourceComplianceByPackOutcome> GetAggregateResourceComplianceByPackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceByPackRequest&, const GetAggregateResourceComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceByPackAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceComplianceTimelineResult> GetAggregateResourceComplianceTimelineOutcome;
+			typedef std::future<GetAggregateResourceComplianceTimelineOutcome> GetAggregateResourceComplianceTimelineOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceComplianceTimelineRequest&, const GetAggregateResourceComplianceTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceComplianceTimelineAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceConfigurationTimelineResult> GetAggregateResourceConfigurationTimelineOutcome;
+			typedef std::future<GetAggregateResourceConfigurationTimelineOutcome> GetAggregateResourceConfigurationTimelineOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceConfigurationTimelineRequest&, const GetAggregateResourceConfigurationTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceConfigurationTimelineAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceCountsGroupByRegionResult> GetAggregateResourceCountsGroupByRegionOutcome;
+			typedef std::future<GetAggregateResourceCountsGroupByRegionOutcome> GetAggregateResourceCountsGroupByRegionOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceCountsGroupByRegionRequest&, const GetAggregateResourceCountsGroupByRegionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceCountsGroupByRegionAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregateResourceCountsGroupByResourceTypeResult> GetAggregateResourceCountsGroupByResourceTypeOutcome;
+			typedef std::future<GetAggregateResourceCountsGroupByResourceTypeOutcome> GetAggregateResourceCountsGroupByResourceTypeOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregateResourceCountsGroupByResourceTypeRequest&, const GetAggregateResourceCountsGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregateResourceCountsGroupByResourceTypeAsyncHandler;
+			typedef Outcome<Error, Model::GetAggregatorResult> GetAggregatorOutcome;
+			typedef std::future<GetAggregatorOutcome> GetAggregatorOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetAggregatorRequest&, const GetAggregatorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAggregatorAsyncHandler;
+			typedef Outcome<Error, Model::GetCompliancePackResult> GetCompliancePackOutcome;
+			typedef std::future<GetCompliancePackOutcome> GetCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetCompliancePackRequest&, const GetCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::GetCompliancePackReportResult> GetCompliancePackReportOutcome;
+			typedef std::future<GetCompliancePackReportOutcome> GetCompliancePackReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetCompliancePackReportRequest&, const GetCompliancePackReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCompliancePackReportAsyncHandler;
+			typedef Outcome<Error, Model::GetConfigRuleResult> GetConfigRuleOutcome;
+			typedef std::future<GetConfigRuleOutcome> GetConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetConfigRuleRequest&, const GetConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetConfigRuleComplianceByPackResult> GetConfigRuleComplianceByPackOutcome;
+			typedef std::future<GetConfigRuleComplianceByPackOutcome> GetConfigRuleComplianceByPackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetConfigRuleComplianceByPackRequest&, const GetConfigRuleComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConfigRuleComplianceByPackAsyncHandler;
+			typedef Outcome<Error, Model::GetConfigRuleSummaryByRiskLevelResult> GetConfigRuleSummaryByRiskLevelOutcome;
+			typedef std::future<GetConfigRuleSummaryByRiskLevelOutcome> GetConfigRuleSummaryByRiskLevelOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetConfigRuleSummaryByRiskLevelRequest&, const GetConfigRuleSummaryByRiskLevelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConfigRuleSummaryByRiskLevelAsyncHandler;
+			typedef Outcome<Error, Model::GetConfigRulesReportResult> GetConfigRulesReportOutcome;
+			typedef std::future<GetConfigRulesReportOutcome> GetConfigRulesReportOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetConfigRulesReportRequest&, const GetConfigRulesReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConfigRulesReportAsyncHandler;
+			typedef Outcome<Error, Model::GetDiscoveredResourceCountsGroupByRegionResult> GetDiscoveredResourceCountsGroupByRegionOutcome;
+			typedef std::future<GetDiscoveredResourceCountsGroupByRegionOutcome> GetDiscoveredResourceCountsGroupByRegionOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetDiscoveredResourceCountsGroupByRegionRequest&, const GetDiscoveredResourceCountsGroupByRegionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiscoveredResourceCountsGroupByRegionAsyncHandler;
+			typedef Outcome<Error, Model::GetDiscoveredResourceCountsGroupByResourceTypeResult> GetDiscoveredResourceCountsGroupByResourceTypeOutcome;
+			typedef std::future<GetDiscoveredResourceCountsGroupByResourceTypeOutcome> GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest&, const GetDiscoveredResourceCountsGroupByResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDiscoveredResourceCountsGroupByResourceTypeAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceComplianceByConfigRuleResult> GetResourceComplianceByConfigRuleOutcome;
+			typedef std::future<GetResourceComplianceByConfigRuleOutcome> GetResourceComplianceByConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceByConfigRuleRequest&, const GetResourceComplianceByConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceByConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceComplianceByPackResult> GetResourceComplianceByPackOutcome;
+			typedef std::future<GetResourceComplianceByPackOutcome> GetResourceComplianceByPackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::GetResourceComplianceByPackRequest&, const GetResourceComplianceByPackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceComplianceByPackAsyncHandler;
 			typedef Outcome<Error, Model::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;
+			typedef Outcome<Error, Model::IgnoreAggregateEvaluationResultsResult> IgnoreAggregateEvaluationResultsOutcome;
+			typedef std::future<IgnoreAggregateEvaluationResultsOutcome> IgnoreAggregateEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::IgnoreAggregateEvaluationResultsRequest&, const IgnoreAggregateEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IgnoreAggregateEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::IgnoreEvaluationResultsResult> IgnoreEvaluationResultsOutcome;
+			typedef std::future<IgnoreEvaluationResultsOutcome> IgnoreEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::IgnoreEvaluationResultsRequest&, const IgnoreEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IgnoreEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::ListAggregateCompliancePacksResult> ListAggregateCompliancePacksOutcome;
+			typedef std::future<ListAggregateCompliancePacksOutcome> ListAggregateCompliancePacksOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListAggregateCompliancePacksRequest&, const ListAggregateCompliancePacksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAggregateCompliancePacksAsyncHandler;
+			typedef Outcome<Error, Model::ListAggregateConfigRuleEvaluationResultsResult> ListAggregateConfigRuleEvaluationResultsOutcome;
+			typedef std::future<ListAggregateConfigRuleEvaluationResultsOutcome> ListAggregateConfigRuleEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListAggregateConfigRuleEvaluationResultsRequest&, const ListAggregateConfigRuleEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAggregateConfigRuleEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::ListAggregateConfigRulesResult> ListAggregateConfigRulesOutcome;
+			typedef std::future<ListAggregateConfigRulesOutcome> ListAggregateConfigRulesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListAggregateConfigRulesRequest&, const ListAggregateConfigRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAggregateConfigRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListAggregateResourceEvaluationResultsResult> ListAggregateResourceEvaluationResultsOutcome;
+			typedef std::future<ListAggregateResourceEvaluationResultsOutcome> ListAggregateResourceEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListAggregateResourceEvaluationResultsRequest&, const ListAggregateResourceEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAggregateResourceEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::ListAggregatorsResult> ListAggregatorsOutcome;
+			typedef std::future<ListAggregatorsOutcome> ListAggregatorsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListAggregatorsRequest&, const ListAggregatorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAggregatorsAsyncHandler;
+			typedef Outcome<Error, Model::ListCompliancePackTemplatesResult> ListCompliancePackTemplatesOutcome;
+			typedef std::future<ListCompliancePackTemplatesOutcome> ListCompliancePackTemplatesOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListCompliancePackTemplatesRequest&, const ListCompliancePackTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCompliancePackTemplatesAsyncHandler;
+			typedef Outcome<Error, Model::ListCompliancePacksResult> ListCompliancePacksOutcome;
+			typedef std::future<ListCompliancePacksOutcome> ListCompliancePacksOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListCompliancePacksRequest&, const ListCompliancePacksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCompliancePacksAsyncHandler;
+			typedef Outcome<Error, Model::ListConfigRuleEvaluationResultsResult> ListConfigRuleEvaluationResultsOutcome;
+			typedef std::future<ListConfigRuleEvaluationResultsOutcome> ListConfigRuleEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListConfigRuleEvaluationResultsRequest&, const ListConfigRuleEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConfigRuleEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::ListResourceEvaluationResultsResult> ListResourceEvaluationResultsOutcome;
+			typedef std::future<ListResourceEvaluationResultsOutcome> ListResourceEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::ListResourceEvaluationResultsRequest&, const ListResourceEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::RevertAggregateEvaluationResultsResult> RevertAggregateEvaluationResultsOutcome;
+			typedef std::future<RevertAggregateEvaluationResultsOutcome> RevertAggregateEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::RevertAggregateEvaluationResultsRequest&, const RevertAggregateEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevertAggregateEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::RevertEvaluationResultsResult> RevertEvaluationResultsOutcome;
+			typedef std::future<RevertEvaluationResultsOutcome> RevertEvaluationResultsOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::RevertEvaluationResultsRequest&, const RevertEvaluationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevertEvaluationResultsAsyncHandler;
+			typedef Outcome<Error, Model::StartAggregateConfigRuleEvaluationResult> StartAggregateConfigRuleEvaluationOutcome;
+			typedef std::future<StartAggregateConfigRuleEvaluationOutcome> StartAggregateConfigRuleEvaluationOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::StartAggregateConfigRuleEvaluationRequest&, const StartAggregateConfigRuleEvaluationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartAggregateConfigRuleEvaluationAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAggregateCompliancePackResult> UpdateAggregateCompliancePackOutcome;
+			typedef std::future<UpdateAggregateCompliancePackOutcome> UpdateAggregateCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::UpdateAggregateCompliancePackRequest&, const UpdateAggregateCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAggregateCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAggregateConfigRuleResult> UpdateAggregateConfigRuleOutcome;
+			typedef std::future<UpdateAggregateConfigRuleOutcome> UpdateAggregateConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::UpdateAggregateConfigRuleRequest&, const UpdateAggregateConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAggregateConfigRuleAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAggregatorResult> UpdateAggregatorOutcome;
+			typedef std::future<UpdateAggregatorOutcome> UpdateAggregatorOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::UpdateAggregatorRequest&, const UpdateAggregatorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAggregatorAsyncHandler;
+			typedef Outcome<Error, Model::UpdateCompliancePackResult> UpdateCompliancePackOutcome;
+			typedef std::future<UpdateCompliancePackOutcome> UpdateCompliancePackOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::UpdateCompliancePackRequest&, const UpdateCompliancePackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCompliancePackAsyncHandler;
+			typedef Outcome<Error, Model::UpdateConfigRuleResult> UpdateConfigRuleOutcome;
+			typedef std::future<UpdateConfigRuleOutcome> UpdateConfigRuleOutcomeCallable;
+			typedef std::function<void(const ConfigClient*, const Model::UpdateConfigRuleRequest&, const UpdateConfigRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateConfigRuleAsyncHandler;
 
 			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;
+			ActiveAggregateConfigRulesOutcome activeAggregateConfigRules(const Model::ActiveAggregateConfigRulesRequest &request)const;
+			void activeAggregateConfigRulesAsync(const Model::ActiveAggregateConfigRulesRequest& request, const ActiveAggregateConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ActiveAggregateConfigRulesOutcomeCallable activeAggregateConfigRulesCallable(const Model::ActiveAggregateConfigRulesRequest& request) const;
+			AttachAggregateConfigRuleToCompliancePackOutcome attachAggregateConfigRuleToCompliancePack(const Model::AttachAggregateConfigRuleToCompliancePackRequest &request)const;
+			void attachAggregateConfigRuleToCompliancePackAsync(const Model::AttachAggregateConfigRuleToCompliancePackRequest& request, const AttachAggregateConfigRuleToCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachAggregateConfigRuleToCompliancePackOutcomeCallable attachAggregateConfigRuleToCompliancePackCallable(const Model::AttachAggregateConfigRuleToCompliancePackRequest& request) const;
+			AttachConfigRuleToCompliancePackOutcome attachConfigRuleToCompliancePack(const Model::AttachConfigRuleToCompliancePackRequest &request)const;
+			void attachConfigRuleToCompliancePackAsync(const Model::AttachConfigRuleToCompliancePackRequest& request, const AttachConfigRuleToCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachConfigRuleToCompliancePackOutcomeCallable attachConfigRuleToCompliancePackCallable(const Model::AttachConfigRuleToCompliancePackRequest& request) const;
+			CreateAggregateCompliancePackOutcome createAggregateCompliancePack(const Model::CreateAggregateCompliancePackRequest &request)const;
+			void createAggregateCompliancePackAsync(const Model::CreateAggregateCompliancePackRequest& request, const CreateAggregateCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAggregateCompliancePackOutcomeCallable createAggregateCompliancePackCallable(const Model::CreateAggregateCompliancePackRequest& request) const;
+			CreateAggregateConfigRuleOutcome createAggregateConfigRule(const Model::CreateAggregateConfigRuleRequest &request)const;
+			void createAggregateConfigRuleAsync(const Model::CreateAggregateConfigRuleRequest& request, const CreateAggregateConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAggregateConfigRuleOutcomeCallable createAggregateConfigRuleCallable(const Model::CreateAggregateConfigRuleRequest& request) const;
+			CreateAggregatorOutcome createAggregator(const Model::CreateAggregatorRequest &request)const;
+			void createAggregatorAsync(const Model::CreateAggregatorRequest& request, const CreateAggregatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAggregatorOutcomeCallable createAggregatorCallable(const Model::CreateAggregatorRequest& request) const;
+			CreateCompliancePackOutcome createCompliancePack(const Model::CreateCompliancePackRequest &request)const;
+			void createCompliancePackAsync(const Model::CreateCompliancePackRequest& request, const CreateCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCompliancePackOutcomeCallable createCompliancePackCallable(const Model::CreateCompliancePackRequest& request) const;
+			CreateConfigRuleOutcome createConfigRule(const Model::CreateConfigRuleRequest &request)const;
+			void createConfigRuleAsync(const Model::CreateConfigRuleRequest& request, const CreateConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateConfigRuleOutcomeCallable createConfigRuleCallable(const Model::CreateConfigRuleRequest& request) const;
+			DeactiveAggregateConfigRulesOutcome deactiveAggregateConfigRules(const Model::DeactiveAggregateConfigRulesRequest &request)const;
+			void deactiveAggregateConfigRulesAsync(const Model::DeactiveAggregateConfigRulesRequest& request, const DeactiveAggregateConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeactiveAggregateConfigRulesOutcomeCallable deactiveAggregateConfigRulesCallable(const Model::DeactiveAggregateConfigRulesRequest& request) const;
+			DeactiveConfigRulesOutcome deactiveConfigRules(const Model::DeactiveConfigRulesRequest &request)const;
+			void deactiveConfigRulesAsync(const Model::DeactiveConfigRulesRequest& request, const DeactiveConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeactiveConfigRulesOutcomeCallable deactiveConfigRulesCallable(const Model::DeactiveConfigRulesRequest& request) const;
+			DeleteAggregateCompliancePacksOutcome deleteAggregateCompliancePacks(const Model::DeleteAggregateCompliancePacksRequest &request)const;
+			void deleteAggregateCompliancePacksAsync(const Model::DeleteAggregateCompliancePacksRequest& request, const DeleteAggregateCompliancePacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAggregateCompliancePacksOutcomeCallable deleteAggregateCompliancePacksCallable(const Model::DeleteAggregateCompliancePacksRequest& request) const;
+			DeleteAggregateConfigRulesOutcome deleteAggregateConfigRules(const Model::DeleteAggregateConfigRulesRequest &request)const;
+			void deleteAggregateConfigRulesAsync(const Model::DeleteAggregateConfigRulesRequest& request, const DeleteAggregateConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAggregateConfigRulesOutcomeCallable deleteAggregateConfigRulesCallable(const Model::DeleteAggregateConfigRulesRequest& request) const;
+			DeleteAggregatorsOutcome deleteAggregators(const Model::DeleteAggregatorsRequest &request)const;
+			void deleteAggregatorsAsync(const Model::DeleteAggregatorsRequest& request, const DeleteAggregatorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAggregatorsOutcomeCallable deleteAggregatorsCallable(const Model::DeleteAggregatorsRequest& request) const;
+			DeleteCompliancePacksOutcome deleteCompliancePacks(const Model::DeleteCompliancePacksRequest &request)const;
+			void deleteCompliancePacksAsync(const Model::DeleteCompliancePacksRequest& request, const DeleteCompliancePacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCompliancePacksOutcomeCallable deleteCompliancePacksCallable(const Model::DeleteCompliancePacksRequest& request) const;
+			DetachAggregateConfigRuleToCompliancePackOutcome detachAggregateConfigRuleToCompliancePack(const Model::DetachAggregateConfigRuleToCompliancePackRequest &request)const;
+			void detachAggregateConfigRuleToCompliancePackAsync(const Model::DetachAggregateConfigRuleToCompliancePackRequest& request, const DetachAggregateConfigRuleToCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachAggregateConfigRuleToCompliancePackOutcomeCallable detachAggregateConfigRuleToCompliancePackCallable(const Model::DetachAggregateConfigRuleToCompliancePackRequest& request) const;
+			DetachConfigRuleToCompliancePackOutcome detachConfigRuleToCompliancePack(const Model::DetachConfigRuleToCompliancePackRequest &request)const;
+			void detachConfigRuleToCompliancePackAsync(const Model::DetachConfigRuleToCompliancePackRequest& request, const DetachConfigRuleToCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachConfigRuleToCompliancePackOutcomeCallable detachConfigRuleToCompliancePackCallable(const Model::DetachConfigRuleToCompliancePackRequest& request) const;
+			GenerateAggregateCompliancePackReportOutcome generateAggregateCompliancePackReport(const Model::GenerateAggregateCompliancePackReportRequest &request)const;
+			void generateAggregateCompliancePackReportAsync(const Model::GenerateAggregateCompliancePackReportRequest& request, const GenerateAggregateCompliancePackReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateAggregateCompliancePackReportOutcomeCallable generateAggregateCompliancePackReportCallable(const Model::GenerateAggregateCompliancePackReportRequest& request) const;
+			GenerateAggregateConfigRulesReportOutcome generateAggregateConfigRulesReport(const Model::GenerateAggregateConfigRulesReportRequest &request)const;
+			void generateAggregateConfigRulesReportAsync(const Model::GenerateAggregateConfigRulesReportRequest& request, const GenerateAggregateConfigRulesReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateAggregateConfigRulesReportOutcomeCallable generateAggregateConfigRulesReportCallable(const Model::GenerateAggregateConfigRulesReportRequest& request) const;
+			GenerateCompliancePackReportOutcome generateCompliancePackReport(const Model::GenerateCompliancePackReportRequest &request)const;
+			void generateCompliancePackReportAsync(const Model::GenerateCompliancePackReportRequest& request, const GenerateCompliancePackReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateCompliancePackReportOutcomeCallable generateCompliancePackReportCallable(const Model::GenerateCompliancePackReportRequest& request) const;
+			GenerateConfigRulesReportOutcome generateConfigRulesReport(const Model::GenerateConfigRulesReportRequest &request)const;
+			void generateConfigRulesReportAsync(const Model::GenerateConfigRulesReportRequest& request, const GenerateConfigRulesReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateConfigRulesReportOutcomeCallable generateConfigRulesReportCallable(const Model::GenerateConfigRulesReportRequest& request) const;
+			GetAggregateAccountComplianceByPackOutcome getAggregateAccountComplianceByPack(const Model::GetAggregateAccountComplianceByPackRequest &request)const;
+			void getAggregateAccountComplianceByPackAsync(const Model::GetAggregateAccountComplianceByPackRequest& request, const GetAggregateAccountComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateAccountComplianceByPackOutcomeCallable getAggregateAccountComplianceByPackCallable(const Model::GetAggregateAccountComplianceByPackRequest& request) const;
+			GetAggregateCompliancePackOutcome getAggregateCompliancePack(const Model::GetAggregateCompliancePackRequest &request)const;
+			void getAggregateCompliancePackAsync(const Model::GetAggregateCompliancePackRequest& request, const GetAggregateCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateCompliancePackOutcomeCallable getAggregateCompliancePackCallable(const Model::GetAggregateCompliancePackRequest& request) const;
+			GetAggregateCompliancePackReportOutcome getAggregateCompliancePackReport(const Model::GetAggregateCompliancePackReportRequest &request)const;
+			void getAggregateCompliancePackReportAsync(const Model::GetAggregateCompliancePackReportRequest& request, const GetAggregateCompliancePackReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateCompliancePackReportOutcomeCallable getAggregateCompliancePackReportCallable(const Model::GetAggregateCompliancePackReportRequest& request) const;
+			GetAggregateConfigRuleOutcome getAggregateConfigRule(const Model::GetAggregateConfigRuleRequest &request)const;
+			void getAggregateConfigRuleAsync(const Model::GetAggregateConfigRuleRequest& request, const GetAggregateConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateConfigRuleOutcomeCallable getAggregateConfigRuleCallable(const Model::GetAggregateConfigRuleRequest& request) const;
+			GetAggregateConfigRuleComplianceByPackOutcome getAggregateConfigRuleComplianceByPack(const Model::GetAggregateConfigRuleComplianceByPackRequest &request)const;
+			void getAggregateConfigRuleComplianceByPackAsync(const Model::GetAggregateConfigRuleComplianceByPackRequest& request, const GetAggregateConfigRuleComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateConfigRuleComplianceByPackOutcomeCallable getAggregateConfigRuleComplianceByPackCallable(const Model::GetAggregateConfigRuleComplianceByPackRequest& request) const;
+			GetAggregateConfigRuleSummaryByRiskLevelOutcome getAggregateConfigRuleSummaryByRiskLevel(const Model::GetAggregateConfigRuleSummaryByRiskLevelRequest &request)const;
+			void getAggregateConfigRuleSummaryByRiskLevelAsync(const Model::GetAggregateConfigRuleSummaryByRiskLevelRequest& request, const GetAggregateConfigRuleSummaryByRiskLevelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateConfigRuleSummaryByRiskLevelOutcomeCallable getAggregateConfigRuleSummaryByRiskLevelCallable(const Model::GetAggregateConfigRuleSummaryByRiskLevelRequest& request) const;
+			GetAggregateConfigRulesReportOutcome getAggregateConfigRulesReport(const Model::GetAggregateConfigRulesReportRequest &request)const;
+			void getAggregateConfigRulesReportAsync(const Model::GetAggregateConfigRulesReportRequest& request, const GetAggregateConfigRulesReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateConfigRulesReportOutcomeCallable getAggregateConfigRulesReportCallable(const Model::GetAggregateConfigRulesReportRequest& request) const;
+			GetAggregateResourceComplianceByConfigRuleOutcome getAggregateResourceComplianceByConfigRule(const Model::GetAggregateResourceComplianceByConfigRuleRequest &request)const;
+			void getAggregateResourceComplianceByConfigRuleAsync(const Model::GetAggregateResourceComplianceByConfigRuleRequest& request, const GetAggregateResourceComplianceByConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceComplianceByConfigRuleOutcomeCallable getAggregateResourceComplianceByConfigRuleCallable(const Model::GetAggregateResourceComplianceByConfigRuleRequest& request) const;
+			GetAggregateResourceComplianceByPackOutcome getAggregateResourceComplianceByPack(const Model::GetAggregateResourceComplianceByPackRequest &request)const;
+			void getAggregateResourceComplianceByPackAsync(const Model::GetAggregateResourceComplianceByPackRequest& request, const GetAggregateResourceComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceComplianceByPackOutcomeCallable getAggregateResourceComplianceByPackCallable(const Model::GetAggregateResourceComplianceByPackRequest& request) const;
+			GetAggregateResourceComplianceTimelineOutcome getAggregateResourceComplianceTimeline(const Model::GetAggregateResourceComplianceTimelineRequest &request)const;
+			void getAggregateResourceComplianceTimelineAsync(const Model::GetAggregateResourceComplianceTimelineRequest& request, const GetAggregateResourceComplianceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceComplianceTimelineOutcomeCallable getAggregateResourceComplianceTimelineCallable(const Model::GetAggregateResourceComplianceTimelineRequest& request) const;
+			GetAggregateResourceConfigurationTimelineOutcome getAggregateResourceConfigurationTimeline(const Model::GetAggregateResourceConfigurationTimelineRequest &request)const;
+			void getAggregateResourceConfigurationTimelineAsync(const Model::GetAggregateResourceConfigurationTimelineRequest& request, const GetAggregateResourceConfigurationTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceConfigurationTimelineOutcomeCallable getAggregateResourceConfigurationTimelineCallable(const Model::GetAggregateResourceConfigurationTimelineRequest& request) const;
+			GetAggregateResourceCountsGroupByRegionOutcome getAggregateResourceCountsGroupByRegion(const Model::GetAggregateResourceCountsGroupByRegionRequest &request)const;
+			void getAggregateResourceCountsGroupByRegionAsync(const Model::GetAggregateResourceCountsGroupByRegionRequest& request, const GetAggregateResourceCountsGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceCountsGroupByRegionOutcomeCallable getAggregateResourceCountsGroupByRegionCallable(const Model::GetAggregateResourceCountsGroupByRegionRequest& request) const;
+			GetAggregateResourceCountsGroupByResourceTypeOutcome getAggregateResourceCountsGroupByResourceType(const Model::GetAggregateResourceCountsGroupByResourceTypeRequest &request)const;
+			void getAggregateResourceCountsGroupByResourceTypeAsync(const Model::GetAggregateResourceCountsGroupByResourceTypeRequest& request, const GetAggregateResourceCountsGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregateResourceCountsGroupByResourceTypeOutcomeCallable getAggregateResourceCountsGroupByResourceTypeCallable(const Model::GetAggregateResourceCountsGroupByResourceTypeRequest& request) const;
+			GetAggregatorOutcome getAggregator(const Model::GetAggregatorRequest &request)const;
+			void getAggregatorAsync(const Model::GetAggregatorRequest& request, const GetAggregatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAggregatorOutcomeCallable getAggregatorCallable(const Model::GetAggregatorRequest& request) const;
+			GetCompliancePackOutcome getCompliancePack(const Model::GetCompliancePackRequest &request)const;
+			void getCompliancePackAsync(const Model::GetCompliancePackRequest& request, const GetCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCompliancePackOutcomeCallable getCompliancePackCallable(const Model::GetCompliancePackRequest& request) const;
+			GetCompliancePackReportOutcome getCompliancePackReport(const Model::GetCompliancePackReportRequest &request)const;
+			void getCompliancePackReportAsync(const Model::GetCompliancePackReportRequest& request, const GetCompliancePackReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCompliancePackReportOutcomeCallable getCompliancePackReportCallable(const Model::GetCompliancePackReportRequest& request) const;
+			GetConfigRuleOutcome getConfigRule(const Model::GetConfigRuleRequest &request)const;
+			void getConfigRuleAsync(const Model::GetConfigRuleRequest& request, const GetConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetConfigRuleOutcomeCallable getConfigRuleCallable(const Model::GetConfigRuleRequest& request) const;
+			GetConfigRuleComplianceByPackOutcome getConfigRuleComplianceByPack(const Model::GetConfigRuleComplianceByPackRequest &request)const;
+			void getConfigRuleComplianceByPackAsync(const Model::GetConfigRuleComplianceByPackRequest& request, const GetConfigRuleComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetConfigRuleComplianceByPackOutcomeCallable getConfigRuleComplianceByPackCallable(const Model::GetConfigRuleComplianceByPackRequest& request) const;
+			GetConfigRuleSummaryByRiskLevelOutcome getConfigRuleSummaryByRiskLevel(const Model::GetConfigRuleSummaryByRiskLevelRequest &request)const;
+			void getConfigRuleSummaryByRiskLevelAsync(const Model::GetConfigRuleSummaryByRiskLevelRequest& request, const GetConfigRuleSummaryByRiskLevelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetConfigRuleSummaryByRiskLevelOutcomeCallable getConfigRuleSummaryByRiskLevelCallable(const Model::GetConfigRuleSummaryByRiskLevelRequest& request) const;
+			GetConfigRulesReportOutcome getConfigRulesReport(const Model::GetConfigRulesReportRequest &request)const;
+			void getConfigRulesReportAsync(const Model::GetConfigRulesReportRequest& request, const GetConfigRulesReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetConfigRulesReportOutcomeCallable getConfigRulesReportCallable(const Model::GetConfigRulesReportRequest& request) const;
+			GetDiscoveredResourceCountsGroupByRegionOutcome getDiscoveredResourceCountsGroupByRegion(const Model::GetDiscoveredResourceCountsGroupByRegionRequest &request)const;
+			void getDiscoveredResourceCountsGroupByRegionAsync(const Model::GetDiscoveredResourceCountsGroupByRegionRequest& request, const GetDiscoveredResourceCountsGroupByRegionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDiscoveredResourceCountsGroupByRegionOutcomeCallable getDiscoveredResourceCountsGroupByRegionCallable(const Model::GetDiscoveredResourceCountsGroupByRegionRequest& request) const;
+			GetDiscoveredResourceCountsGroupByResourceTypeOutcome getDiscoveredResourceCountsGroupByResourceType(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest &request)const;
+			void getDiscoveredResourceCountsGroupByResourceTypeAsync(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest& request, const GetDiscoveredResourceCountsGroupByResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDiscoveredResourceCountsGroupByResourceTypeOutcomeCallable getDiscoveredResourceCountsGroupByResourceTypeCallable(const Model::GetDiscoveredResourceCountsGroupByResourceTypeRequest& request) const;
+			GetResourceComplianceByConfigRuleOutcome getResourceComplianceByConfigRule(const Model::GetResourceComplianceByConfigRuleRequest &request)const;
+			void getResourceComplianceByConfigRuleAsync(const Model::GetResourceComplianceByConfigRuleRequest& request, const GetResourceComplianceByConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceComplianceByConfigRuleOutcomeCallable getResourceComplianceByConfigRuleCallable(const Model::GetResourceComplianceByConfigRuleRequest& request) const;
+			GetResourceComplianceByPackOutcome getResourceComplianceByPack(const Model::GetResourceComplianceByPackRequest &request)const;
+			void getResourceComplianceByPackAsync(const Model::GetResourceComplianceByPackRequest& request, const GetResourceComplianceByPackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceComplianceByPackOutcomeCallable getResourceComplianceByPackCallable(const Model::GetResourceComplianceByPackRequest& request) const;
 			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;
+			IgnoreAggregateEvaluationResultsOutcome ignoreAggregateEvaluationResults(const Model::IgnoreAggregateEvaluationResultsRequest &request)const;
+			void ignoreAggregateEvaluationResultsAsync(const Model::IgnoreAggregateEvaluationResultsRequest& request, const IgnoreAggregateEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			IgnoreAggregateEvaluationResultsOutcomeCallable ignoreAggregateEvaluationResultsCallable(const Model::IgnoreAggregateEvaluationResultsRequest& request) const;
+			IgnoreEvaluationResultsOutcome ignoreEvaluationResults(const Model::IgnoreEvaluationResultsRequest &request)const;
+			void ignoreEvaluationResultsAsync(const Model::IgnoreEvaluationResultsRequest& request, const IgnoreEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			IgnoreEvaluationResultsOutcomeCallable ignoreEvaluationResultsCallable(const Model::IgnoreEvaluationResultsRequest& request) const;
+			ListAggregateCompliancePacksOutcome listAggregateCompliancePacks(const Model::ListAggregateCompliancePacksRequest &request)const;
+			void listAggregateCompliancePacksAsync(const Model::ListAggregateCompliancePacksRequest& request, const ListAggregateCompliancePacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAggregateCompliancePacksOutcomeCallable listAggregateCompliancePacksCallable(const Model::ListAggregateCompliancePacksRequest& request) const;
+			ListAggregateConfigRuleEvaluationResultsOutcome listAggregateConfigRuleEvaluationResults(const Model::ListAggregateConfigRuleEvaluationResultsRequest &request)const;
+			void listAggregateConfigRuleEvaluationResultsAsync(const Model::ListAggregateConfigRuleEvaluationResultsRequest& request, const ListAggregateConfigRuleEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAggregateConfigRuleEvaluationResultsOutcomeCallable listAggregateConfigRuleEvaluationResultsCallable(const Model::ListAggregateConfigRuleEvaluationResultsRequest& request) const;
+			ListAggregateConfigRulesOutcome listAggregateConfigRules(const Model::ListAggregateConfigRulesRequest &request)const;
+			void listAggregateConfigRulesAsync(const Model::ListAggregateConfigRulesRequest& request, const ListAggregateConfigRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAggregateConfigRulesOutcomeCallable listAggregateConfigRulesCallable(const Model::ListAggregateConfigRulesRequest& request) const;
+			ListAggregateResourceEvaluationResultsOutcome listAggregateResourceEvaluationResults(const Model::ListAggregateResourceEvaluationResultsRequest &request)const;
+			void listAggregateResourceEvaluationResultsAsync(const Model::ListAggregateResourceEvaluationResultsRequest& request, const ListAggregateResourceEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAggregateResourceEvaluationResultsOutcomeCallable listAggregateResourceEvaluationResultsCallable(const Model::ListAggregateResourceEvaluationResultsRequest& request) const;
+			ListAggregatorsOutcome listAggregators(const Model::ListAggregatorsRequest &request)const;
+			void listAggregatorsAsync(const Model::ListAggregatorsRequest& request, const ListAggregatorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAggregatorsOutcomeCallable listAggregatorsCallable(const Model::ListAggregatorsRequest& request) const;
+			ListCompliancePackTemplatesOutcome listCompliancePackTemplates(const Model::ListCompliancePackTemplatesRequest &request)const;
+			void listCompliancePackTemplatesAsync(const Model::ListCompliancePackTemplatesRequest& request, const ListCompliancePackTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCompliancePackTemplatesOutcomeCallable listCompliancePackTemplatesCallable(const Model::ListCompliancePackTemplatesRequest& request) const;
+			ListCompliancePacksOutcome listCompliancePacks(const Model::ListCompliancePacksRequest &request)const;
+			void listCompliancePacksAsync(const Model::ListCompliancePacksRequest& request, const ListCompliancePacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCompliancePacksOutcomeCallable listCompliancePacksCallable(const Model::ListCompliancePacksRequest& request) const;
+			ListConfigRuleEvaluationResultsOutcome listConfigRuleEvaluationResults(const Model::ListConfigRuleEvaluationResultsRequest &request)const;
+			void listConfigRuleEvaluationResultsAsync(const Model::ListConfigRuleEvaluationResultsRequest& request, const ListConfigRuleEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListConfigRuleEvaluationResultsOutcomeCallable listConfigRuleEvaluationResultsCallable(const Model::ListConfigRuleEvaluationResultsRequest& request) const;
+			ListResourceEvaluationResultsOutcome listResourceEvaluationResults(const Model::ListResourceEvaluationResultsRequest &request)const;
+			void listResourceEvaluationResultsAsync(const Model::ListResourceEvaluationResultsRequest& request, const ListResourceEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListResourceEvaluationResultsOutcomeCallable listResourceEvaluationResultsCallable(const Model::ListResourceEvaluationResultsRequest& request) const;
+			RevertAggregateEvaluationResultsOutcome revertAggregateEvaluationResults(const Model::RevertAggregateEvaluationResultsRequest &request)const;
+			void revertAggregateEvaluationResultsAsync(const Model::RevertAggregateEvaluationResultsRequest& request, const RevertAggregateEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RevertAggregateEvaluationResultsOutcomeCallable revertAggregateEvaluationResultsCallable(const Model::RevertAggregateEvaluationResultsRequest& request) const;
+			RevertEvaluationResultsOutcome revertEvaluationResults(const Model::RevertEvaluationResultsRequest &request)const;
+			void revertEvaluationResultsAsync(const Model::RevertEvaluationResultsRequest& request, const RevertEvaluationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RevertEvaluationResultsOutcomeCallable revertEvaluationResultsCallable(const Model::RevertEvaluationResultsRequest& request) const;
+			StartAggregateConfigRuleEvaluationOutcome startAggregateConfigRuleEvaluation(const Model::StartAggregateConfigRuleEvaluationRequest &request)const;
+			void startAggregateConfigRuleEvaluationAsync(const Model::StartAggregateConfigRuleEvaluationRequest& request, const StartAggregateConfigRuleEvaluationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartAggregateConfigRuleEvaluationOutcomeCallable startAggregateConfigRuleEvaluationCallable(const Model::StartAggregateConfigRuleEvaluationRequest& request) const;
+			UpdateAggregateCompliancePackOutcome updateAggregateCompliancePack(const Model::UpdateAggregateCompliancePackRequest &request)const;
+			void updateAggregateCompliancePackAsync(const Model::UpdateAggregateCompliancePackRequest& request, const UpdateAggregateCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAggregateCompliancePackOutcomeCallable updateAggregateCompliancePackCallable(const Model::UpdateAggregateCompliancePackRequest& request) const;
+			UpdateAggregateConfigRuleOutcome updateAggregateConfigRule(const Model::UpdateAggregateConfigRuleRequest &request)const;
+			void updateAggregateConfigRuleAsync(const Model::UpdateAggregateConfigRuleRequest& request, const UpdateAggregateConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAggregateConfigRuleOutcomeCallable updateAggregateConfigRuleCallable(const Model::UpdateAggregateConfigRuleRequest& request) const;
+			UpdateAggregatorOutcome updateAggregator(const Model::UpdateAggregatorRequest &request)const;
+			void updateAggregatorAsync(const Model::UpdateAggregatorRequest& request, const UpdateAggregatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAggregatorOutcomeCallable updateAggregatorCallable(const Model::UpdateAggregatorRequest& request) const;
+			UpdateCompliancePackOutcome updateCompliancePack(const Model::UpdateCompliancePackRequest &request)const;
+			void updateCompliancePackAsync(const Model::UpdateCompliancePackRequest& request, const UpdateCompliancePackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateCompliancePackOutcomeCallable updateCompliancePackCallable(const Model::UpdateCompliancePackRequest& request) const;
+			UpdateConfigRuleOutcome updateConfigRule(const Model::UpdateConfigRuleRequest &request)const;
+			void updateConfigRuleAsync(const Model::UpdateConfigRuleRequest& request, const UpdateConfigRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateConfigRuleOutcomeCallable updateConfigRuleCallable(const Model::UpdateConfigRuleRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

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

config/include/alibabacloud/config/model/ActiveAggregateConfigRulesResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_STOPCONFIGRULESRESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_STOPCONFIGRULESRESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_ACTIVEAGGREGATECONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_ACTIVEAGGREGATECONFIGRULESRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,7 +29,7 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT StopConfigRulesResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT ActiveAggregateConfigRulesResult : public ServiceResult
 			{
 			public:
 				struct OperateRuleResult
@@ -44,9 +44,9 @@ namespace AlibabaCloud
 				};
 
 
-				StopConfigRulesResult();
-				explicit StopConfigRulesResult(const std::string &payload);
-				~StopConfigRulesResult();
+				ActiveAggregateConfigRulesResult();
+				explicit ActiveAggregateConfigRulesResult(const std::string &payload);
+				~ActiveAggregateConfigRulesResult();
 				OperateRuleResult getOperateRuleResult()const;
 
 			protected:
@@ -58,4 +58,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_STOPCONFIGRULESRESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_ACTIVEAGGREGATECONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/AttachAggregateConfigRuleToCompliancePackRequest.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_ATTACHAGGREGATECONFIGRULETOCOMPLIANCEPACKREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_ATTACHAGGREGATECONFIGRULETOCOMPLIANCEPACKREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT AttachAggregateConfigRuleToCompliancePackRequest : public RpcServiceRequest {
+public:
+	AttachAggregateConfigRuleToCompliancePackRequest();
+	~AttachAggregateConfigRuleToCompliancePackRequest();
+	std::string getConfigRuleIds() const;
+	void setConfigRuleIds(const std::string &configRuleIds);
+	std::string getAggregatorId() const;
+	void setAggregatorId(const std::string &aggregatorId);
+	std::string getCompliancePackId() const;
+	void setCompliancePackId(const std::string &compliancePackId);
+
+private:
+	std::string configRuleIds_;
+	std::string aggregatorId_;
+	std::string compliancePackId_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_ATTACHAGGREGATECONFIGRULETOCOMPLIANCEPACKREQUEST_H_

config/include/alibabacloud/config/model/AttachAggregateConfigRuleToCompliancePackResult.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_ATTACHAGGREGATECONFIGRULETOCOMPLIANCEPACKRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_ATTACHAGGREGATECONFIGRULETOCOMPLIANCEPACKRESULT_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 AttachAggregateConfigRuleToCompliancePackResult : public ServiceResult
+			{
+			public:
+				struct OperateRuleResult
+				{
+					struct OperateRuleItem
+					{
+						std::string configRuleId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateRuleItem> operateRuleItemList;
+				};
+
+
+				AttachAggregateConfigRuleToCompliancePackResult();
+				explicit AttachAggregateConfigRuleToCompliancePackResult(const std::string &payload);
+				~AttachAggregateConfigRuleToCompliancePackResult();
+				OperateRuleResult getOperateRuleResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OperateRuleResult operateRuleResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_ATTACHAGGREGATECONFIGRULETOCOMPLIANCEPACKRESULT_H_

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

config/include/alibabacloud/config/model/AttachConfigRuleToCompliancePackResult.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_ATTACHCONFIGRULETOCOMPLIANCEPACKRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_ATTACHCONFIGRULETOCOMPLIANCEPACKRESULT_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 AttachConfigRuleToCompliancePackResult : public ServiceResult
+			{
+			public:
+				struct OperateRuleResult
+				{
+					struct OperateRuleItem
+					{
+						std::string configRuleId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateRuleItem> operateRuleItemList;
+				};
+
+
+				AttachConfigRuleToCompliancePackResult();
+				explicit AttachConfigRuleToCompliancePackResult(const std::string &payload);
+				~AttachConfigRuleToCompliancePackResult();
+				OperateRuleResult getOperateRuleResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OperateRuleResult operateRuleResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_ATTACHCONFIGRULETOCOMPLIANCEPACKRESULT_H_

config/include/alibabacloud/config/model/CreateAggregateCompliancePackRequest.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_CREATEAGGREGATECOMPLIANCEPACKREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECOMPLIANCEPACKREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT CreateAggregateCompliancePackRequest : public RpcServiceRequest {
+public:
+	struct ConfigRules {
+		std::string managedRuleIdentifier;
+		struct ConfigRuleParametersItem {
+			std::string parameterValue;
+			std::string parameterName;
+		};
+		ConfigRuleParametersItem configRuleParametersItem;
+		std::vector<ConfigRuleParametersItem> configRuleParameters;
+		std::string configRuleId;
+		std::string configRuleName;
+		std::string description;
+		int riskLevel;
+	};
+	CreateAggregateCompliancePackRequest();
+	~CreateAggregateCompliancePackRequest();
+	std::vector<ConfigRules> getConfigRules() const;
+	void setConfigRules(const std::vector<ConfigRules> &configRules);
+	std::string getCompliancePackName() const;
+	void setCompliancePackName(const std::string &compliancePackName);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getCompliancePackTemplateId() const;
+	void setCompliancePackTemplateId(const std::string &compliancePackTemplateId);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getAggregatorId() const;
+	void setAggregatorId(const std::string &aggregatorId);
+	int getRiskLevel() const;
+	void setRiskLevel(int riskLevel);
+
+private:
+	std::vector<ConfigRules> configRules_;
+	std::string compliancePackName_;
+	std::string clientToken_;
+	std::string compliancePackTemplateId_;
+	std::string description_;
+	std::string aggregatorId_;
+	int riskLevel_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECOMPLIANCEPACKREQUEST_H_

config/include/alibabacloud/config/model/CreateAggregateCompliancePackResult.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_CREATEAGGREGATECOMPLIANCEPACKRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECOMPLIANCEPACKRESULT_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 CreateAggregateCompliancePackResult : public ServiceResult
+			{
+			public:
+
+
+				CreateAggregateCompliancePackResult();
+				explicit CreateAggregateCompliancePackResult(const std::string &payload);
+				~CreateAggregateCompliancePackResult();
+				std::string getCompliancePackId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string compliancePackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECOMPLIANCEPACKRESULT_H_

config/include/alibabacloud/config/model/CreateAggregateConfigRuleRequest.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_CREATEAGGREGATECONFIGRULEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECONFIGRULEREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT CreateAggregateConfigRuleRequest : public RpcServiceRequest {
+public:
+	CreateAggregateConfigRuleRequest();
+	~CreateAggregateConfigRuleRequest();
+	std::string getTagKeyScope() const;
+	void setTagKeyScope(const std::string &tagKeyScope);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<std::string> getResourceTypesScope() const;
+	void setResourceTypesScope(const std::vector<std::string> &resourceTypesScope);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getAggregatorId() const;
+	void setAggregatorId(const std::string &aggregatorId);
+	std::string getConfigRuleTriggerTypes() const;
+	void setConfigRuleTriggerTypes(const std::string &configRuleTriggerTypes);
+	std::string getSourceIdentifier() const;
+	void setSourceIdentifier(const std::string &sourceIdentifier);
+	std::string getTagValueScope() const;
+	void setTagValueScope(const std::string &tagValueScope);
+	std::string getRegionIdsScope() const;
+	void setRegionIdsScope(const std::string &regionIdsScope);
+	int getRiskLevel() const;
+	void setRiskLevel(int riskLevel);
+	std::string getSourceOwner() const;
+	void setSourceOwner(const std::string &sourceOwner);
+	std::string getResourceGroupIdsScope() const;
+	void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope);
+	std::string getInputParameters() const;
+	void setInputParameters(const std::string &inputParameters);
+	std::string getConfigRuleName() const;
+	void setConfigRuleName(const std::string &configRuleName);
+	std::string getMaximumExecutionFrequency() const;
+	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
+	std::string getExcludeResourceIdsScope() const;
+	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+
+private:
+	std::string tagKeyScope_;
+	std::string clientToken_;
+	std::vector<std::string> resourceTypesScope_;
+	std::string description_;
+	std::string aggregatorId_;
+	std::string configRuleTriggerTypes_;
+	std::string sourceIdentifier_;
+	std::string tagValueScope_;
+	std::string regionIdsScope_;
+	int riskLevel_;
+	std::string sourceOwner_;
+	std::string resourceGroupIdsScope_;
+	std::string inputParameters_;
+	std::string configRuleName_;
+	std::string maximumExecutionFrequency_;
+	std::string excludeResourceIdsScope_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECONFIGRULEREQUEST_H_

config/include/alibabacloud/config/model/CreateAggregateConfigRuleResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESRESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESRESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECONFIGRULERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECONFIGRULERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,23 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT GetSupportedResourceTypesResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT CreateAggregateConfigRuleResult : public ServiceResult
 			{
 			public:
 
 
-				GetSupportedResourceTypesResult();
-				explicit GetSupportedResourceTypesResult(const std::string &payload);
-				~GetSupportedResourceTypesResult();
-				std::vector<std::string> getResourceTypes()const;
+				CreateAggregateConfigRuleResult();
+				explicit CreateAggregateConfigRuleResult(const std::string &payload);
+				~CreateAggregateConfigRuleResult();
+				std::string getConfigRuleId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<std::string> resourceTypes_;
+				std::string configRuleId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_GETSUPPORTEDRESOURCETYPESRESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATECONFIGRULERESULT_H_

config/include/alibabacloud/config/model/CreateAggregatorRequest.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_CREATEAGGREGATORREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATORREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT CreateAggregatorRequest : public RpcServiceRequest {
+public:
+	struct AggregatorAccounts {
+		long accountId;
+		std::string accountName;
+		std::string accountType;
+	};
+	CreateAggregatorRequest();
+	~CreateAggregatorRequest();
+	std::string getAggregatorType() const;
+	void setAggregatorType(const std::string &aggregatorType);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAggregatorName() const;
+	void setAggregatorName(const std::string &aggregatorName);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::vector<AggregatorAccounts> getAggregatorAccounts() const;
+	void setAggregatorAccounts(const std::vector<AggregatorAccounts> &aggregatorAccounts);
+
+private:
+	std::string aggregatorType_;
+	std::string clientToken_;
+	std::string aggregatorName_;
+	std::string description_;
+	std::vector<AggregatorAccounts> aggregatorAccounts_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATORREQUEST_H_

config/include/alibabacloud/config/model/CreateAggregatorResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELRESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELRESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATORRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATORRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,23 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT PutDeliveryChannelResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT CreateAggregatorResult : public ServiceResult
 			{
 			public:
 
 
-				PutDeliveryChannelResult();
-				explicit PutDeliveryChannelResult(const std::string &payload);
-				~PutDeliveryChannelResult();
-				std::string getDeliveryChannelId()const;
+				CreateAggregatorResult();
+				explicit CreateAggregatorResult(const std::string &payload);
+				~CreateAggregatorResult();
+				std::string getAggregatorId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string deliveryChannelId_;
+				std::string aggregatorId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTDELIVERYCHANNELRESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATEAGGREGATORRESULT_H_

config/include/alibabacloud/config/model/CreateCompliancePackRequest.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_CREATECOMPLIANCEPACKREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATECOMPLIANCEPACKREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT CreateCompliancePackRequest : public RpcServiceRequest {
+public:
+	struct ConfigRules {
+		std::string managedRuleIdentifier;
+		struct ConfigRuleParametersItem {
+			std::string parameterValue;
+			std::string parameterName;
+		};
+		ConfigRuleParametersItem configRuleParametersItem;
+		std::vector<ConfigRuleParametersItem> configRuleParameters;
+		std::string configRuleId;
+		std::string configRuleName;
+		std::string description;
+		int riskLevel;
+	};
+	CreateCompliancePackRequest();
+	~CreateCompliancePackRequest();
+	std::vector<ConfigRules> getConfigRules() const;
+	void setConfigRules(const std::vector<ConfigRules> &configRules);
+	std::string getCompliancePackName() const;
+	void setCompliancePackName(const std::string &compliancePackName);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getCompliancePackTemplateId() const;
+	void setCompliancePackTemplateId(const std::string &compliancePackTemplateId);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	int getRiskLevel() const;
+	void setRiskLevel(int riskLevel);
+
+private:
+	std::vector<ConfigRules> configRules_;
+	std::string compliancePackName_;
+	std::string clientToken_;
+	std::string compliancePackTemplateId_;
+	std::string description_;
+	int riskLevel_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATECOMPLIANCEPACKREQUEST_H_

config/include/alibabacloud/config/model/CreateCompliancePackResult.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_CREATECOMPLIANCEPACKRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATECOMPLIANCEPACKRESULT_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 CreateCompliancePackResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCompliancePackResult();
+				explicit CreateCompliancePackResult(const std::string &payload);
+				~CreateCompliancePackResult();
+				std::string getCompliancePackId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string compliancePackId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATECOMPLIANCEPACKRESULT_H_

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

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_CONFIG_MODEL_CREATECONFIGRULEREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATECONFIGRULEREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT CreateConfigRuleRequest : public RpcServiceRequest {
+public:
+	CreateConfigRuleRequest();
+	~CreateConfigRuleRequest();
+	std::string getTagKeyScope() const;
+	void setTagKeyScope(const std::string &tagKeyScope);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<std::string> getResourceTypesScope() const;
+	void setResourceTypesScope(const std::vector<std::string> &resourceTypesScope);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getConfigRuleTriggerTypes() const;
+	void setConfigRuleTriggerTypes(const std::string &configRuleTriggerTypes);
+	std::string getSourceIdentifier() const;
+	void setSourceIdentifier(const std::string &sourceIdentifier);
+	std::string getTagValueScope() const;
+	void setTagValueScope(const std::string &tagValueScope);
+	std::string getRegionIdsScope() const;
+	void setRegionIdsScope(const std::string &regionIdsScope);
+	int getRiskLevel() const;
+	void setRiskLevel(int riskLevel);
+	std::string getSourceOwner() const;
+	void setSourceOwner(const std::string &sourceOwner);
+	std::string getResourceGroupIdsScope() const;
+	void setResourceGroupIdsScope(const std::string &resourceGroupIdsScope);
+	std::string getInputParameters() const;
+	void setInputParameters(const std::string &inputParameters);
+	std::string getConfigRuleName() const;
+	void setConfigRuleName(const std::string &configRuleName);
+	std::string getMaximumExecutionFrequency() const;
+	void setMaximumExecutionFrequency(const std::string &maximumExecutionFrequency);
+	std::string getExcludeResourceIdsScope() const;
+	void setExcludeResourceIdsScope(const std::string &excludeResourceIdsScope);
+
+private:
+	std::string tagKeyScope_;
+	std::string clientToken_;
+	std::vector<std::string> resourceTypesScope_;
+	std::string description_;
+	std::string configRuleTriggerTypes_;
+	std::string sourceIdentifier_;
+	std::string tagValueScope_;
+	std::string regionIdsScope_;
+	int riskLevel_;
+	std::string sourceOwner_;
+	std::string resourceGroupIdsScope_;
+	std::string inputParameters_;
+	std::string configRuleName_;
+	std::string maximumExecutionFrequency_;
+	std::string excludeResourceIdsScope_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATECONFIGRULEREQUEST_H_

config/include/alibabacloud/config/model/CreateConfigRuleResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULERESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULERESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_CREATECONFIGRULERESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_CREATECONFIGRULERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT PutConfigRuleResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT CreateConfigRuleResult : public ServiceResult
 			{
 			public:
 
 
-				PutConfigRuleResult();
-				explicit PutConfigRuleResult(const std::string &payload);
-				~PutConfigRuleResult();
+				CreateConfigRuleResult();
+				explicit CreateConfigRuleResult(const std::string &payload);
+				~CreateConfigRuleResult();
 				std::string getConfigRuleId()const;
 
 			protected:
@@ -48,4 +48,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_PUTCONFIGRULERESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_CREATECONFIGRULERESULT_H_

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

config/include/alibabacloud/config/model/DeactiveAggregateConfigRulesResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCESUMMARYRESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCESUMMARYRESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_DEACTIVEAGGREGATECONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DEACTIVEAGGREGATECONFIGRULESRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,29 +29,33 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT GetDiscoveredResourceSummaryResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT DeactiveAggregateConfigRulesResult : public ServiceResult
 			{
 			public:
-				struct DiscoveredResourceSummary
+				struct OperateRuleResult
 				{
-					int resourceTypeCount;
-					int resourceCount;
-					int regionCount;
+					struct OperateRuleItem
+					{
+						std::string configRuleId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateRuleItem> operateRuleItemList;
 				};
 
 
-				GetDiscoveredResourceSummaryResult();
-				explicit GetDiscoveredResourceSummaryResult(const std::string &payload);
-				~GetDiscoveredResourceSummaryResult();
-				DiscoveredResourceSummary getDiscoveredResourceSummary()const;
+				DeactiveAggregateConfigRulesResult();
+				explicit DeactiveAggregateConfigRulesResult(const std::string &payload);
+				~DeactiveAggregateConfigRulesResult();
+				OperateRuleResult getOperateRuleResult()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				DiscoveredResourceSummary discoveredResourceSummary_;
+				OperateRuleResult operateRuleResult_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_GETDISCOVEREDRESOURCESUMMARYRESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DEACTIVEAGGREGATECONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/DeactiveConfigRulesRequest.h

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

config/include/alibabacloud/config/model/DeactiveConfigRulesResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_ACTIVECONFIGRULESRESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_ACTIVECONFIGRULESRESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_DEACTIVECONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DEACTIVECONFIGRULESRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,7 +29,7 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT ActiveConfigRulesResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT DeactiveConfigRulesResult : public ServiceResult
 			{
 			public:
 				struct OperateRuleResult
@@ -44,9 +44,9 @@ namespace AlibabaCloud
 				};
 
 
-				ActiveConfigRulesResult();
-				explicit ActiveConfigRulesResult(const std::string &payload);
-				~ActiveConfigRulesResult();
+				DeactiveConfigRulesResult();
+				explicit DeactiveConfigRulesResult(const std::string &payload);
+				~DeactiveConfigRulesResult();
 				OperateRuleResult getOperateRuleResult()const;
 
 			protected:
@@ -58,4 +58,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_ACTIVECONFIGRULESRESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DEACTIVECONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/DeleteAggregateCompliancePacksRequest.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_DELETEAGGREGATECOMPLIANCEPACKSREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECOMPLIANCEPACKSREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT DeleteAggregateCompliancePacksRequest : public RpcServiceRequest {
+public:
+	DeleteAggregateCompliancePacksRequest();
+	~DeleteAggregateCompliancePacksRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAggregatorId() const;
+	void setAggregatorId(const std::string &aggregatorId);
+	std::string getCompliancePackIds() const;
+	void setCompliancePackIds(const std::string &compliancePackIds);
+	bool getDeleteRule() const;
+	void setDeleteRule(bool deleteRule);
+
+private:
+	std::string clientToken_;
+	std::string aggregatorId_;
+	std::string compliancePackIds_;
+	bool deleteRule_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECOMPLIANCEPACKSREQUEST_H_

config/include/alibabacloud/config/model/DeleteAggregateCompliancePacksResult.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_DELETEAGGREGATECOMPLIANCEPACKSRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECOMPLIANCEPACKSRESULT_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 DeleteAggregateCompliancePacksResult : public ServiceResult
+			{
+			public:
+				struct OperateCompliancePacksResult
+				{
+					struct OperateCompliancePacksItem
+					{
+						std::string compliancePackId;
+						std::string errorCode;
+						bool success;
+					};
+					std::vector<OperateCompliancePacksItem> operateCompliancePacks;
+				};
+
+
+				DeleteAggregateCompliancePacksResult();
+				explicit DeleteAggregateCompliancePacksResult(const std::string &payload);
+				~DeleteAggregateCompliancePacksResult();
+				OperateCompliancePacksResult getOperateCompliancePacksResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				OperateCompliancePacksResult operateCompliancePacksResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECOMPLIANCEPACKSRESULT_H_

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

config/include/alibabacloud/config/model/DeleteAggregateConfigRulesResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CONFIG_MODEL_DELETECONFIGRULESRESULT_H_
-#define ALIBABACLOUD_CONFIG_MODEL_DELETECONFIGRULESRESULT_H_
+#ifndef ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECONFIGRULESRESULT_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECONFIGRULESRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,7 +29,7 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CONFIG_EXPORT DeleteConfigRulesResult : public ServiceResult
+			class ALIBABACLOUD_CONFIG_EXPORT DeleteAggregateConfigRulesResult : public ServiceResult
 			{
 			public:
 				struct OperateRuleResult
@@ -44,9 +44,9 @@ namespace AlibabaCloud
 				};
 
 
-				DeleteConfigRulesResult();
-				explicit DeleteConfigRulesResult(const std::string &payload);
-				~DeleteConfigRulesResult();
+				DeleteAggregateConfigRulesResult();
+				explicit DeleteAggregateConfigRulesResult(const std::string &payload);
+				~DeleteAggregateConfigRulesResult();
 				OperateRuleResult getOperateRuleResult()const;
 
 			protected:
@@ -58,4 +58,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CONFIG_MODEL_DELETECONFIGRULESRESULT_H_
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATECONFIGRULESRESULT_H_

config/include/alibabacloud/config/model/DeleteAggregatorsRequest.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_DELETEAGGREGATORSREQUEST_H_
+#define ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATORSREQUEST_H_
+
+#include <alibabacloud/config/ConfigExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Config {
+namespace Model {
+class ALIBABACLOUD_CONFIG_EXPORT DeleteAggregatorsRequest : public RpcServiceRequest {
+public:
+	DeleteAggregatorsRequest();
+	~DeleteAggregatorsRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getAggregatorIds() const;
+	void setAggregatorIds(const std::string &aggregatorIds);
+
+private:
+	std::string clientToken_;
+	std::string aggregatorIds_;
+};
+} // namespace Model
+} // namespace Config
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CONFIG_MODEL_DELETEAGGREGATORSREQUEST_H_