Add Request Param Ipv6AddressCount For API CreateLaunchTemplate AND CreateLaunchTemplateVersion.

CHANGELOG

@@ -1,3 +1,406 @@
+2021-12-20 Version: 1.36.986
+- Add Request Param Ipv6AddressCount For API CreateLaunchTemplate AND CreateLaunchTemplateVersion.
+- Add Response Data Ipv6AddressCount For API DescribeLaunchTemplateVersions.
+
+2021-12-20 Version: 1.36.985
+- Generated 2016-04-08 for `Emr`.
+
+2021-12-17 Version: 1.36.984
+- Support Endpoint Protect.
+
+2021-12-17 Version: 1.36.983
+- Supported ACL for SMB.
+
+2021-12-16 Version: 1.36.982
+- Release for sprint 2_2_0.
+
+2021-12-16 Version: 1.36.981
+- Update OTA API, including CreateOTADynamicUpgradeJob,CreateOTAStaticUpgradeJob,QueryOTAJob.
+
+2021-12-14 Version: 1.36.980
+- Support query resourceType.
+
+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.
+
+2021-11-29 Version: 1.36.955
+- Update DescribeCdnSMCertificateDetail.
+
+2021-11-29 Version: 1.36.954
+- Update SetDcdnDomainSMCertificate.
+
+2021-11-29 Version: 1.36.953
+- Generated 2016-11-01 for `live`.
+
+2021-11-26 Version: 1.36.952
+- Support CEN Qos Apis.
+- Support TransitRouter Latest Apis.
+
+2021-11-26 Version: 1.36.951
+- Update GetSyncResult.
+
+2021-11-25 Version: 1.36.950
+- Supported new features etc.
+
+2021-11-25 Version: 1.36.949
+- Supported new features etc.
+
+2021-11-25 Version: 1.36.948
+- Supported new features for outbound.
+
+2021-11-25 Version: 1.36.947
+- Delete some abandoned interface.
+- Add some interfaces.
+
+2021-11-25 Version: 1.36.946
+- Minor changes.
+
+2021-11-24 Version: 1.36.945
+- Delete some abandoned interface in SDK.
+
+2021-11-24 Version: 1.36.944
+- Set API DescribeVodDomainSrcBpsData to public.
+
+2021-11-23 Version: 1.36.943
+- Delete some abandoned interface in SDK.
+- Add AutoLiveStream series interfaces.
+- Add UpdateMPUTask, CreateRecordIndexFile interfaces.
+
+2021-11-23 Version: 1.36.942
+- Update RecognizeCharacter.
+
+2021-11-23 Version: 1.36.941
+- Generated 2016-04-08 for `Emr`.
+
+2021-11-23 Version: 1.36.940
+- Fix BdsColdStorage.
+
+2021-11-23 Version: 1.36.939
+- Support the IP restrictions in ram policy.
+
+2021-11-19 Version: 1.36.938
+- Add site monitoring dial DNS_ match_ rule.
+
+2021-11-17 Version: 1.36.937
+- Update apm interface parameter.
+
+2021-11-16 Version: 1.36.936
+- Add parameter type HDRType.
+
+2021-11-16 Version: 1.36.935
+- Update apm interface parameter.
+
+2021-11-16 Version: 1.36.934
+- Update apm interface parameter.
+
+2021-11-16 Version: 1.36.933
+- Generated 2017-12-28 for `ddoscoo`.
+
+2021-11-16 Version: 1.36.932
+- Update SetCdnDomainSMCertificate.
+
+2021-11-16 Version: 1.36.931
+- Update apm interface parameter.
+
+2021-11-15 Version: 1.36.930
+- Generated 2020-01-01 for `ddoscoo`.
+
+2021-11-15 Version: 1.36.929
+- Add Ext parameter to image translation API.
+
+2021-11-15 Version: 1.36.928
+- Update DetectVehicleICongestion DetectVehicleIllegalParking.
+
+2021-11-12 Version: 1.36.927
+- Update by sdk platform.
+
+2021-11-12 Version: 1.36.926
+- Optimize the API for querying storage package information.
+
+2021-11-08 Version: 1.36.925
+- Supported apm restful api.
+
+2021-11-05 Version: 1.36.924
+- Add SetDcdnDomainSMCertificate.
+
+2021-11-05 Version: 1.36.923
+- Add SetCdnDomainSMCertificate.
+
+2021-11-05 Version: 1.36.922
+- Update OTA API, including CreateOTAVerifyJob.
+
+2021-11-04 Version: 1.36.921
+- Adjust some param.
+
+2021-11-02 Version: 1.36.920
+- Add GetVideoPlayAuth API parameter.
+
+2021-11-02 Version: 1.36.919
+- Add GetVideoPlayAuth API parameter.
+
+2021-11-02 Version: 1.36.918
+- Support multi language.
+
+2021-11-02 Version: 1.36.917
+- Add API UploadStreamByURL.
+
+2021-11-02 Version: 1.36.916
+- Fixed SDK update delay.
+
+2021-11-01 Version: 1.36.915
+- Release DetectKitchenAnimals DetectWorkwear.
+
+2021-10-28 Version: 1.36.914
+- Add no data alarm processing.
+
+2021-10-28 Version: 1.36.913
+- Updated tag api.
+- Updated DescribeTask api to get relatedResourceId info.
+
+2021-10-27 Version: 1.36.912
+- Fix ModifyInstanceName.
+
+2021-10-26 Version: 1.36.911
+- Add QueryEmbedTokenInfo,DeleteEmbedToken,CreateEmbedToken,DelayEmbedToken,BuildSignatureUrl, and update QueryDatasetInfo,AuthorizeMenu,AddUserTagMeta,AddUser.
+
+2021-10-26 Version: 1.36.910
+- Update Dyvmsapi SDK.
+
+2021-10-25 Version: 1.36.909
+- DescribeDtsJobs api, delay filed change from int to long.
+
+2021-10-25 Version: 1.36.908
+- Generated 2016-04-08 for `Emr`.
+
+2021-10-25 Version: 1.36.907
+- Generated 2016-11-01 for `live`.
+
+2021-10-21 Version: 1.36.906
+- Update Open API.
+
+2021-10-21 Version: 1.36.905
+- Generated 2020-05-18 for `dataworks-public`.
+
+2021-10-21 Version: 1.36.904
+- Release AddQualityScore.
+
+2021-10-21 Version: 1.36.903
+- Generated 2020-05-18 for `dataworks-public`.
+
+2021-10-20 Version: 1.36.902
+- Add DeviceCenter API, including CreateDeviceDynamicGroup, DeleteDeviceDynamicGroup, QueryDynamicGroupDevices.
+- Update DeviceCenter API, including SetDeviceGroupTags, QueryDeviceGroupByFuzzyName, QueryDeviceGroupByDevice, QueryDeviceGroupTagList, UpdateDeviceGroup, QueryDeviceGroupList, QueryDeviceGroupInfo.
+- Update OTA API, including CreateOTADynamicUpgradeJob, CreateOTAStaticUpgradeJob, QueryOTAJob.
+
+2021-10-19 Version: 1.36.901
+- Supported ScaleApp totalPartitions.
+
+2021-10-18 Version: 1.36.900
+- Generated 2019-09-10, 2018-01-17 for `waf-openapi`.
+
+2021-10-18 Version: 1.36.899
+- Adjust ecs openapi endpoint.
+- Fix SDK array format.
+
+2021-10-15 Version: 1.36.898
+- Added audit status.
+
+2021-10-15 Version: 1.36.897
+- Generated 2020-02-01 for `cloudesl`.
+
+2021-10-14 Version: 1.36.896
+- Add API for predictive dialer.
+
+2021-10-08 Version: 1.36.895
+- Adjust ecs openapi endpoint.
+
+2021-10-08 Version: 1.36.894
+- Fixed SDK update delay.
+
+2021-10-08 Version: 1.36.893
+- Fixed SDK update delay.
+
+2021-10-08 Version: 1.36.892
+- Fixed SDK update delay.
+
+2021-10-08 Version: 1.36.891
+- Release SearchFace BatchAddFaces.
+
+2021-09-29 Version: 1.36.890
+- Supported AssumeRoleWithOIDC.
+
+2021-09-28 Version: 1.36.889
+- Add new internal API.
+
+2021-09-26 Version: 1.36.888
+- Support odcap device.
+
+2021-09-26 Version: 1.36.887
+- Support odcap device.
+
+2021-09-26 Version: 1.36.886
+- Update imageenhan.
+
+2021-09-26 Version: 1.36.885
+- Supported sdk for sddp.
+
+2021-09-24 Version: 1.36.884
+- Release RetouchSkin LiquifyFace.
+
+2021-09-23 Version: 1.36.883
+- Supports the purchase of polardb storage packages.
+- Support temporary upgrades and allocations of instances.
+- Query the detailed information of the node returned by the GDN instance.
+
+2021-09-23 Version: 1.36.882
+- Update by sdk platform.
+
+2021-09-22 Version: 1.36.881
+- Supported API for GTM.
+
+2021-09-22 Version: 1.36.880
+- Modify CreateK8sSecret.
+
+2021-09-18 Version: 1.36.879
+- Add copyright invasion detection APIs.
+
+2021-09-17 Version: 1.36.878
+- Supported SendChannels, AndroidMessageHuaweiUrgency, AndroidMessageHuaweiCategory for Push and MassPush.
+
+2021-09-16 Version: 1.36.877
+- Generated 2016-11-01 for `live`.
+
+2021-09-15 Version: 1.36.876
+- Update AddFace SearchFace.
+
+2021-09-14 Version: 1.36.875
+- Add DiskIds for CreateSnapshotGroup.
+
+2021-09-14 Version: 1.36.874
+- Add DiskIds for CreateSnapshotGroup.
+
+2021-09-13 Version: 1.36.873
+- Generated 2019-03-01 for `LinkWAN`.
+
+2021-09-13 Version: 1.36.872
+- Supported CallerLocation, CalleeLocation in CDR API.
+
+2021-09-10 Version: 1.36.871
+- Support crop face image.
+
+2021-09-09 Version: 1.36.870
+- Public version.
+
+2021-09-09 Version: 1.36.869
+- Public version.
+
+2021-09-06 Version: 1.36.868
+- Update LinkSpeech API, including SpeechByCombination, SyncSpeechByCombination.
+
+2021-09-01 Version: 1.36.867
+- SubmitURLUploadJob, support S3 Storage.
+
+2021-09-01 Version: 1.36.866
+- SDK updated.
+
+2021-08-31 Version: 1.36.865
+- Supported cro algorithm.
+
+2021-08-31 Version: 1.36.864
+- Supported AndroidBigPictureUrl, AndroidInboxBody, AndroidImageUrl, AndroidOppoImageId, AndroidXiaomiImageUrl, iOSNotificationThreadId for Push and MassPush.
+
+2021-08-31 Version: 1.36.863
+- Release BeautifyBody.
+
+2021-08-31 Version: 1.36.862
+- Generated 2017-08-01 for `Edas`.
+
+2021-08-27 Version: 1.36.861
+- ListAvailableEcsTypes set param ZoneId not required.
+- ListAvailableEcsTypes return ZoneIds.
+
+2021-08-26 Version: 1.36.860
+- ListAvailableEcsTypes set param ZoneId not required.
+- ListAvailableEcsTypes return ZoneIds.
+
+2021-08-24 Version: 1.36.859
+- Release RetouchBody.
+
+2021-08-20 Version: 1.36.858
+- Update Dyvmsapi SDK.
+- Add GetCallInfo.
+
 2021-08-19 Version: 1.36.857
 - Add SupportSessionManager for DescribeCloudAssistantStatus.
 

VERSION

@@ -1 +1 @@
-1.36.857
+1.36.986

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

@@ -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_UPDATELOADBALANCERZONESRESULT_H_
+#define ALIBABACLOUD_ALB_MODEL_UPDATELOADBALANCERZONESRESULT_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 UpdateLoadBalancerZonesResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateLoadBalancerZonesResult();
+				explicit UpdateLoadBalancerZonesResult(const std::string &payload);
+				~UpdateLoadBalancerZonesResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#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

@@ -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/AttachCommonBandwidthPackageToLoadBalancerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alb;
+using namespace AlibabaCloud::Alb::Model;
+
+AttachCommonBandwidthPackageToLoadBalancerResult::AttachCommonBandwidthPackageToLoadBalancerResult() :
+	ServiceResult()
+{}
+
+AttachCommonBandwidthPackageToLoadBalancerResult::AttachCommonBandwidthPackageToLoadBalancerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AttachCommonBandwidthPackageToLoadBalancerResult::~AttachCommonBandwidthPackageToLoadBalancerResult()
+{}
+
+void AttachCommonBandwidthPackageToLoadBalancerResult::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 AttachCommonBandwidthPackageToLoadBalancerResult::getJobId()const
+{
+	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

@@ -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/UpdateLoadBalancerZonesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alb;
+using namespace AlibabaCloud::Alb::Model;
+
+UpdateLoadBalancerZonesResult::UpdateLoadBalancerZonesResult() :
+	ServiceResult()
+{}
+
+UpdateLoadBalancerZonesResult::UpdateLoadBalancerZonesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateLoadBalancerZonesResult::~UpdateLoadBalancerZonesResult()
+{}
+
+void UpdateLoadBalancerZonesResult::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 UpdateLoadBalancerZonesResult::getJobId()const
+{
+	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_;
 }

alidns/CMakeLists.txt

@@ -55,6 +55,10 @@ set(alidns_public_header_model
 	include/alibabacloud/alidns/model/ChangeDomainOfDnsProductResult.h
 	include/alibabacloud/alidns/model/CopyGtmConfigRequest.h
 	include/alibabacloud/alidns/model/CopyGtmConfigResult.h
+	include/alibabacloud/alidns/model/CreatePdnsAppKeyRequest.h
+	include/alibabacloud/alidns/model/CreatePdnsAppKeyResult.h
+	include/alibabacloud/alidns/model/CreatePdnsUdpIpSegmentRequest.h
+	include/alibabacloud/alidns/model/CreatePdnsUdpIpSegmentResult.h
 	include/alibabacloud/alidns/model/DeleteCustomLinesRequest.h
 	include/alibabacloud/alidns/model/DeleteCustomLinesResult.h
 	include/alibabacloud/alidns/model/DeleteDnsCacheDomainRequest.h
@@ -189,6 +193,28 @@ set(alidns_public_header_model
 	include/alibabacloud/alidns/model/DescribeGtmRecoveryPlansResult.h
 	include/alibabacloud/alidns/model/DescribeInstanceDomainsRequest.h
 	include/alibabacloud/alidns/model/DescribeInstanceDomainsResult.h
+	include/alibabacloud/alidns/model/DescribePdnsAccountSummaryRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsAccountSummaryResult.h
+	include/alibabacloud/alidns/model/DescribePdnsAppKeyRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsAppKeyResult.h
+	include/alibabacloud/alidns/model/DescribePdnsAppKeysRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsAppKeysResult.h
+	include/alibabacloud/alidns/model/DescribePdnsOperateLogsRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsOperateLogsResult.h
+	include/alibabacloud/alidns/model/DescribePdnsRequestStatisticRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsRequestStatisticResult.h
+	include/alibabacloud/alidns/model/DescribePdnsRequestStatisticsRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsRequestStatisticsResult.h
+	include/alibabacloud/alidns/model/DescribePdnsThreatLogsRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsThreatLogsResult.h
+	include/alibabacloud/alidns/model/DescribePdnsThreatStatisticRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsThreatStatisticResult.h
+	include/alibabacloud/alidns/model/DescribePdnsThreatStatisticsRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsThreatStatisticsResult.h
+	include/alibabacloud/alidns/model/DescribePdnsUdpIpSegmentsRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsUdpIpSegmentsResult.h
+	include/alibabacloud/alidns/model/DescribePdnsUserInfoRequest.h
+	include/alibabacloud/alidns/model/DescribePdnsUserInfoResult.h
 	include/alibabacloud/alidns/model/DescribeRecordLogsRequest.h
 	include/alibabacloud/alidns/model/DescribeRecordLogsResult.h
 	include/alibabacloud/alidns/model/DescribeRecordStatisticsRequest.h
@@ -219,8 +245,16 @@ set(alidns_public_header_model
 	include/alibabacloud/alidns/model/MoveGtmResourceGroupResult.h
 	include/alibabacloud/alidns/model/OperateBatchDomainRequest.h
 	include/alibabacloud/alidns/model/OperateBatchDomainResult.h
+	include/alibabacloud/alidns/model/PausePdnsServiceRequest.h
+	include/alibabacloud/alidns/model/PausePdnsServiceResult.h
 	include/alibabacloud/alidns/model/PreviewGtmRecoveryPlanRequest.h
 	include/alibabacloud/alidns/model/PreviewGtmRecoveryPlanResult.h
+	include/alibabacloud/alidns/model/RemovePdnsAppKeyRequest.h
+	include/alibabacloud/alidns/model/RemovePdnsAppKeyResult.h
+	include/alibabacloud/alidns/model/RemovePdnsUdpIpSegmentRequest.h
+	include/alibabacloud/alidns/model/RemovePdnsUdpIpSegmentResult.h
+	include/alibabacloud/alidns/model/ResumePdnsServiceRequest.h
+	include/alibabacloud/alidns/model/ResumePdnsServiceResult.h
 	include/alibabacloud/alidns/model/RetrieveDomainRequest.h
 	include/alibabacloud/alidns/model/RetrieveDomainResult.h
 	include/alibabacloud/alidns/model/RollbackGtmRecoveryPlanRequest.h
@@ -249,6 +283,8 @@ set(alidns_public_header_model
 	include/alibabacloud/alidns/model/UnbindInstanceDomainsResult.h
 	include/alibabacloud/alidns/model/UntagResourcesRequest.h
 	include/alibabacloud/alidns/model/UntagResourcesResult.h
+	include/alibabacloud/alidns/model/UpdateAppKeyStateRequest.h
+	include/alibabacloud/alidns/model/UpdateAppKeyStateResult.h
 	include/alibabacloud/alidns/model/UpdateCustomLineRequest.h
 	include/alibabacloud/alidns/model/UpdateCustomLineResult.h
 	include/alibabacloud/alidns/model/UpdateDNSSLBWeightRequest.h
@@ -282,7 +318,11 @@ set(alidns_public_header_model
 	include/alibabacloud/alidns/model/UpdateGtmMonitorRequest.h
 	include/alibabacloud/alidns/model/UpdateGtmMonitorResult.h
 	include/alibabacloud/alidns/model/UpdateGtmRecoveryPlanRequest.h
-	include/alibabacloud/alidns/model/UpdateGtmRecoveryPlanResult.h )
+	include/alibabacloud/alidns/model/UpdateGtmRecoveryPlanResult.h
+	include/alibabacloud/alidns/model/ValidateDnsGtmCnameRrCanUseRequest.h
+	include/alibabacloud/alidns/model/ValidateDnsGtmCnameRrCanUseResult.h
+	include/alibabacloud/alidns/model/ValidatePdnsUdpIpSegmentRequest.h
+	include/alibabacloud/alidns/model/ValidatePdnsUdpIpSegmentResult.h )
 
 set(alidns_src 
 	src/AlidnsClient.cc
@@ -320,6 +360,10 @@ set(alidns_src
 	src/model/ChangeDomainOfDnsProductResult.cc
 	src/model/CopyGtmConfigRequest.cc
 	src/model/CopyGtmConfigResult.cc
+	src/model/CreatePdnsAppKeyRequest.cc
+	src/model/CreatePdnsAppKeyResult.cc
+	src/model/CreatePdnsUdpIpSegmentRequest.cc
+	src/model/CreatePdnsUdpIpSegmentResult.cc
 	src/model/DeleteCustomLinesRequest.cc
 	src/model/DeleteCustomLinesResult.cc
 	src/model/DeleteDnsCacheDomainRequest.cc
@@ -454,6 +498,28 @@ set(alidns_src
 	src/model/DescribeGtmRecoveryPlansResult.cc
 	src/model/DescribeInstanceDomainsRequest.cc
 	src/model/DescribeInstanceDomainsResult.cc
+	src/model/DescribePdnsAccountSummaryRequest.cc
+	src/model/DescribePdnsAccountSummaryResult.cc
+	src/model/DescribePdnsAppKeyRequest.cc
+	src/model/DescribePdnsAppKeyResult.cc
+	src/model/DescribePdnsAppKeysRequest.cc
+	src/model/DescribePdnsAppKeysResult.cc
+	src/model/DescribePdnsOperateLogsRequest.cc
+	src/model/DescribePdnsOperateLogsResult.cc
+	src/model/DescribePdnsRequestStatisticRequest.cc
+	src/model/DescribePdnsRequestStatisticResult.cc
+	src/model/DescribePdnsRequestStatisticsRequest.cc
+	src/model/DescribePdnsRequestStatisticsResult.cc
+	src/model/DescribePdnsThreatLogsRequest.cc
+	src/model/DescribePdnsThreatLogsResult.cc
+	src/model/DescribePdnsThreatStatisticRequest.cc
+	src/model/DescribePdnsThreatStatisticResult.cc
+	src/model/DescribePdnsThreatStatisticsRequest.cc
+	src/model/DescribePdnsThreatStatisticsResult.cc
+	src/model/DescribePdnsUdpIpSegmentsRequest.cc
+	src/model/DescribePdnsUdpIpSegmentsResult.cc
+	src/model/DescribePdnsUserInfoRequest.cc
+	src/model/DescribePdnsUserInfoResult.cc
 	src/model/DescribeRecordLogsRequest.cc
 	src/model/DescribeRecordLogsResult.cc
 	src/model/DescribeRecordStatisticsRequest.cc
@@ -484,8 +550,16 @@ set(alidns_src
 	src/model/MoveGtmResourceGroupResult.cc
 	src/model/OperateBatchDomainRequest.cc
 	src/model/OperateBatchDomainResult.cc
+	src/model/PausePdnsServiceRequest.cc
+	src/model/PausePdnsServiceResult.cc
 	src/model/PreviewGtmRecoveryPlanRequest.cc
 	src/model/PreviewGtmRecoveryPlanResult.cc
+	src/model/RemovePdnsAppKeyRequest.cc
+	src/model/RemovePdnsAppKeyResult.cc
+	src/model/RemovePdnsUdpIpSegmentRequest.cc
+	src/model/RemovePdnsUdpIpSegmentResult.cc
+	src/model/ResumePdnsServiceRequest.cc
+	src/model/ResumePdnsServiceResult.cc
 	src/model/RetrieveDomainRequest.cc
 	src/model/RetrieveDomainResult.cc
 	src/model/RollbackGtmRecoveryPlanRequest.cc
@@ -514,6 +588,8 @@ set(alidns_src
 	src/model/UnbindInstanceDomainsResult.cc
 	src/model/UntagResourcesRequest.cc
 	src/model/UntagResourcesResult.cc
+	src/model/UpdateAppKeyStateRequest.cc
+	src/model/UpdateAppKeyStateResult.cc
 	src/model/UpdateCustomLineRequest.cc
 	src/model/UpdateCustomLineResult.cc
 	src/model/UpdateDNSSLBWeightRequest.cc
@@ -547,7 +623,11 @@ set(alidns_src
 	src/model/UpdateGtmMonitorRequest.cc
 	src/model/UpdateGtmMonitorResult.cc
 	src/model/UpdateGtmRecoveryPlanRequest.cc
-	src/model/UpdateGtmRecoveryPlanResult.cc )
+	src/model/UpdateGtmRecoveryPlanResult.cc
+	src/model/ValidateDnsGtmCnameRrCanUseRequest.cc
+	src/model/ValidateDnsGtmCnameRrCanUseResult.cc
+	src/model/ValidatePdnsUdpIpSegmentRequest.cc
+	src/model/ValidatePdnsUdpIpSegmentResult.cc )
 
 add_library(alidns ${LIB_TYPE}
 	${alidns_public_header}

alidns/include/alibabacloud/alidns/AlidnsClient.h

@@ -56,6 +56,10 @@
 #include "model/ChangeDomainOfDnsProductResult.h"
 #include "model/CopyGtmConfigRequest.h"
 #include "model/CopyGtmConfigResult.h"
+#include "model/CreatePdnsAppKeyRequest.h"
+#include "model/CreatePdnsAppKeyResult.h"
+#include "model/CreatePdnsUdpIpSegmentRequest.h"
+#include "model/CreatePdnsUdpIpSegmentResult.h"
 #include "model/DeleteCustomLinesRequest.h"
 #include "model/DeleteCustomLinesResult.h"
 #include "model/DeleteDnsCacheDomainRequest.h"
@@ -190,6 +194,28 @@
 #include "model/DescribeGtmRecoveryPlansResult.h"
 #include "model/DescribeInstanceDomainsRequest.h"
 #include "model/DescribeInstanceDomainsResult.h"
+#include "model/DescribePdnsAccountSummaryRequest.h"
+#include "model/DescribePdnsAccountSummaryResult.h"
+#include "model/DescribePdnsAppKeyRequest.h"
+#include "model/DescribePdnsAppKeyResult.h"
+#include "model/DescribePdnsAppKeysRequest.h"
+#include "model/DescribePdnsAppKeysResult.h"
+#include "model/DescribePdnsOperateLogsRequest.h"
+#include "model/DescribePdnsOperateLogsResult.h"
+#include "model/DescribePdnsRequestStatisticRequest.h"
+#include "model/DescribePdnsRequestStatisticResult.h"
+#include "model/DescribePdnsRequestStatisticsRequest.h"
+#include "model/DescribePdnsRequestStatisticsResult.h"
+#include "model/DescribePdnsThreatLogsRequest.h"
+#include "model/DescribePdnsThreatLogsResult.h"
+#include "model/DescribePdnsThreatStatisticRequest.h"
+#include "model/DescribePdnsThreatStatisticResult.h"
+#include "model/DescribePdnsThreatStatisticsRequest.h"
+#include "model/DescribePdnsThreatStatisticsResult.h"
+#include "model/DescribePdnsUdpIpSegmentsRequest.h"
+#include "model/DescribePdnsUdpIpSegmentsResult.h"
+#include "model/DescribePdnsUserInfoRequest.h"
+#include "model/DescribePdnsUserInfoResult.h"
 #include "model/DescribeRecordLogsRequest.h"
 #include "model/DescribeRecordLogsResult.h"
 #include "model/DescribeRecordStatisticsRequest.h"
@@ -220,8 +246,16 @@
 #include "model/MoveGtmResourceGroupResult.h"
 #include "model/OperateBatchDomainRequest.h"
 #include "model/OperateBatchDomainResult.h"
+#include "model/PausePdnsServiceRequest.h"
+#include "model/PausePdnsServiceResult.h"
 #include "model/PreviewGtmRecoveryPlanRequest.h"
 #include "model/PreviewGtmRecoveryPlanResult.h"
+#include "model/RemovePdnsAppKeyRequest.h"
+#include "model/RemovePdnsAppKeyResult.h"
+#include "model/RemovePdnsUdpIpSegmentRequest.h"
+#include "model/RemovePdnsUdpIpSegmentResult.h"
+#include "model/ResumePdnsServiceRequest.h"
+#include "model/ResumePdnsServiceResult.h"
 #include "model/RetrieveDomainRequest.h"
 #include "model/RetrieveDomainResult.h"
 #include "model/RollbackGtmRecoveryPlanRequest.h"
@@ -250,6 +284,8 @@
 #include "model/UnbindInstanceDomainsResult.h"
 #include "model/UntagResourcesRequest.h"
 #include "model/UntagResourcesResult.h"
+#include "model/UpdateAppKeyStateRequest.h"
+#include "model/UpdateAppKeyStateResult.h"
 #include "model/UpdateCustomLineRequest.h"
 #include "model/UpdateCustomLineResult.h"
 #include "model/UpdateDNSSLBWeightRequest.h"
@@ -284,6 +320,10 @@
 #include "model/UpdateGtmMonitorResult.h"
 #include "model/UpdateGtmRecoveryPlanRequest.h"
 #include "model/UpdateGtmRecoveryPlanResult.h"
+#include "model/ValidateDnsGtmCnameRrCanUseRequest.h"
+#include "model/ValidateDnsGtmCnameRrCanUseResult.h"
+#include "model/ValidatePdnsUdpIpSegmentRequest.h"
+#include "model/ValidatePdnsUdpIpSegmentResult.h"
 
 
 namespace AlibabaCloud
@@ -344,6 +384,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CopyGtmConfigResult> CopyGtmConfigOutcome;
 			typedef std::future<CopyGtmConfigOutcome> CopyGtmConfigOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::CopyGtmConfigRequest&, const CopyGtmConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CopyGtmConfigAsyncHandler;
+			typedef Outcome<Error, Model::CreatePdnsAppKeyResult> CreatePdnsAppKeyOutcome;
+			typedef std::future<CreatePdnsAppKeyOutcome> CreatePdnsAppKeyOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::CreatePdnsAppKeyRequest&, const CreatePdnsAppKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePdnsAppKeyAsyncHandler;
+			typedef Outcome<Error, Model::CreatePdnsUdpIpSegmentResult> CreatePdnsUdpIpSegmentOutcome;
+			typedef std::future<CreatePdnsUdpIpSegmentOutcome> CreatePdnsUdpIpSegmentOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::CreatePdnsUdpIpSegmentRequest&, const CreatePdnsUdpIpSegmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePdnsUdpIpSegmentAsyncHandler;
 			typedef Outcome<Error, Model::DeleteCustomLinesResult> DeleteCustomLinesOutcome;
 			typedef std::future<DeleteCustomLinesOutcome> DeleteCustomLinesOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::DeleteCustomLinesRequest&, const DeleteCustomLinesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCustomLinesAsyncHandler;
@@ -545,6 +591,39 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeInstanceDomainsResult> DescribeInstanceDomainsOutcome;
 			typedef std::future<DescribeInstanceDomainsOutcome> DescribeInstanceDomainsOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::DescribeInstanceDomainsRequest&, const DescribeInstanceDomainsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceDomainsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsAccountSummaryResult> DescribePdnsAccountSummaryOutcome;
+			typedef std::future<DescribePdnsAccountSummaryOutcome> DescribePdnsAccountSummaryOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsAccountSummaryRequest&, const DescribePdnsAccountSummaryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsAccountSummaryAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsAppKeyResult> DescribePdnsAppKeyOutcome;
+			typedef std::future<DescribePdnsAppKeyOutcome> DescribePdnsAppKeyOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsAppKeyRequest&, const DescribePdnsAppKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsAppKeyAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsAppKeysResult> DescribePdnsAppKeysOutcome;
+			typedef std::future<DescribePdnsAppKeysOutcome> DescribePdnsAppKeysOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsAppKeysRequest&, const DescribePdnsAppKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsAppKeysAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsOperateLogsResult> DescribePdnsOperateLogsOutcome;
+			typedef std::future<DescribePdnsOperateLogsOutcome> DescribePdnsOperateLogsOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsOperateLogsRequest&, const DescribePdnsOperateLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsOperateLogsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsRequestStatisticResult> DescribePdnsRequestStatisticOutcome;
+			typedef std::future<DescribePdnsRequestStatisticOutcome> DescribePdnsRequestStatisticOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsRequestStatisticRequest&, const DescribePdnsRequestStatisticOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsRequestStatisticAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsRequestStatisticsResult> DescribePdnsRequestStatisticsOutcome;
+			typedef std::future<DescribePdnsRequestStatisticsOutcome> DescribePdnsRequestStatisticsOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsRequestStatisticsRequest&, const DescribePdnsRequestStatisticsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsRequestStatisticsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsThreatLogsResult> DescribePdnsThreatLogsOutcome;
+			typedef std::future<DescribePdnsThreatLogsOutcome> DescribePdnsThreatLogsOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsThreatLogsRequest&, const DescribePdnsThreatLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsThreatLogsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsThreatStatisticResult> DescribePdnsThreatStatisticOutcome;
+			typedef std::future<DescribePdnsThreatStatisticOutcome> DescribePdnsThreatStatisticOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsThreatStatisticRequest&, const DescribePdnsThreatStatisticOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsThreatStatisticAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsThreatStatisticsResult> DescribePdnsThreatStatisticsOutcome;
+			typedef std::future<DescribePdnsThreatStatisticsOutcome> DescribePdnsThreatStatisticsOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsThreatStatisticsRequest&, const DescribePdnsThreatStatisticsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsThreatStatisticsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsUdpIpSegmentsResult> DescribePdnsUdpIpSegmentsOutcome;
+			typedef std::future<DescribePdnsUdpIpSegmentsOutcome> DescribePdnsUdpIpSegmentsOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsUdpIpSegmentsRequest&, const DescribePdnsUdpIpSegmentsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsUdpIpSegmentsAsyncHandler;
+			typedef Outcome<Error, Model::DescribePdnsUserInfoResult> DescribePdnsUserInfoOutcome;
+			typedef std::future<DescribePdnsUserInfoOutcome> DescribePdnsUserInfoOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::DescribePdnsUserInfoRequest&, const DescribePdnsUserInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePdnsUserInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRecordLogsResult> DescribeRecordLogsOutcome;
 			typedef std::future<DescribeRecordLogsOutcome> DescribeRecordLogsOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::DescribeRecordLogsRequest&, const DescribeRecordLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecordLogsAsyncHandler;
@@ -590,9 +669,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::OperateBatchDomainResult> OperateBatchDomainOutcome;
 			typedef std::future<OperateBatchDomainOutcome> OperateBatchDomainOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::OperateBatchDomainRequest&, const OperateBatchDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OperateBatchDomainAsyncHandler;
+			typedef Outcome<Error, Model::PausePdnsServiceResult> PausePdnsServiceOutcome;
+			typedef std::future<PausePdnsServiceOutcome> PausePdnsServiceOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::PausePdnsServiceRequest&, const PausePdnsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PausePdnsServiceAsyncHandler;
 			typedef Outcome<Error, Model::PreviewGtmRecoveryPlanResult> PreviewGtmRecoveryPlanOutcome;
 			typedef std::future<PreviewGtmRecoveryPlanOutcome> PreviewGtmRecoveryPlanOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::PreviewGtmRecoveryPlanRequest&, const PreviewGtmRecoveryPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreviewGtmRecoveryPlanAsyncHandler;
+			typedef Outcome<Error, Model::RemovePdnsAppKeyResult> RemovePdnsAppKeyOutcome;
+			typedef std::future<RemovePdnsAppKeyOutcome> RemovePdnsAppKeyOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::RemovePdnsAppKeyRequest&, const RemovePdnsAppKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemovePdnsAppKeyAsyncHandler;
+			typedef Outcome<Error, Model::RemovePdnsUdpIpSegmentResult> RemovePdnsUdpIpSegmentOutcome;
+			typedef std::future<RemovePdnsUdpIpSegmentOutcome> RemovePdnsUdpIpSegmentOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::RemovePdnsUdpIpSegmentRequest&, const RemovePdnsUdpIpSegmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemovePdnsUdpIpSegmentAsyncHandler;
+			typedef Outcome<Error, Model::ResumePdnsServiceResult> ResumePdnsServiceOutcome;
+			typedef std::future<ResumePdnsServiceOutcome> ResumePdnsServiceOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::ResumePdnsServiceRequest&, const ResumePdnsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumePdnsServiceAsyncHandler;
 			typedef Outcome<Error, Model::RetrieveDomainResult> RetrieveDomainOutcome;
 			typedef std::future<RetrieveDomainOutcome> RetrieveDomainOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::RetrieveDomainRequest&, const RetrieveDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetrieveDomainAsyncHandler;
@@ -635,6 +726,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
 			typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAppKeyStateResult> UpdateAppKeyStateOutcome;
+			typedef std::future<UpdateAppKeyStateOutcome> UpdateAppKeyStateOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::UpdateAppKeyStateRequest&, const UpdateAppKeyStateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAppKeyStateAsyncHandler;
 			typedef Outcome<Error, Model::UpdateCustomLineResult> UpdateCustomLineOutcome;
 			typedef std::future<UpdateCustomLineOutcome> UpdateCustomLineOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::UpdateCustomLineRequest&, const UpdateCustomLineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCustomLineAsyncHandler;
@@ -686,6 +780,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateGtmRecoveryPlanResult> UpdateGtmRecoveryPlanOutcome;
 			typedef std::future<UpdateGtmRecoveryPlanOutcome> UpdateGtmRecoveryPlanOutcomeCallable;
 			typedef std::function<void(const AlidnsClient*, const Model::UpdateGtmRecoveryPlanRequest&, const UpdateGtmRecoveryPlanOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateGtmRecoveryPlanAsyncHandler;
+			typedef Outcome<Error, Model::ValidateDnsGtmCnameRrCanUseResult> ValidateDnsGtmCnameRrCanUseOutcome;
+			typedef std::future<ValidateDnsGtmCnameRrCanUseOutcome> ValidateDnsGtmCnameRrCanUseOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::ValidateDnsGtmCnameRrCanUseRequest&, const ValidateDnsGtmCnameRrCanUseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateDnsGtmCnameRrCanUseAsyncHandler;
+			typedef Outcome<Error, Model::ValidatePdnsUdpIpSegmentResult> ValidatePdnsUdpIpSegmentOutcome;
+			typedef std::future<ValidatePdnsUdpIpSegmentOutcome> ValidatePdnsUdpIpSegmentOutcomeCallable;
+			typedef std::function<void(const AlidnsClient*, const Model::ValidatePdnsUdpIpSegmentRequest&, const ValidatePdnsUdpIpSegmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidatePdnsUdpIpSegmentAsyncHandler;
 
 			AlidnsClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			AlidnsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -742,6 +842,12 @@ namespace AlibabaCloud
 			CopyGtmConfigOutcome copyGtmConfig(const Model::CopyGtmConfigRequest &request)const;
 			void copyGtmConfigAsync(const Model::CopyGtmConfigRequest& request, const CopyGtmConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CopyGtmConfigOutcomeCallable copyGtmConfigCallable(const Model::CopyGtmConfigRequest& request) const;
+			CreatePdnsAppKeyOutcome createPdnsAppKey(const Model::CreatePdnsAppKeyRequest &request)const;
+			void createPdnsAppKeyAsync(const Model::CreatePdnsAppKeyRequest& request, const CreatePdnsAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePdnsAppKeyOutcomeCallable createPdnsAppKeyCallable(const Model::CreatePdnsAppKeyRequest& request) const;
+			CreatePdnsUdpIpSegmentOutcome createPdnsUdpIpSegment(const Model::CreatePdnsUdpIpSegmentRequest &request)const;
+			void createPdnsUdpIpSegmentAsync(const Model::CreatePdnsUdpIpSegmentRequest& request, const CreatePdnsUdpIpSegmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePdnsUdpIpSegmentOutcomeCallable createPdnsUdpIpSegmentCallable(const Model::CreatePdnsUdpIpSegmentRequest& request) const;
 			DeleteCustomLinesOutcome deleteCustomLines(const Model::DeleteCustomLinesRequest &request)const;
 			void deleteCustomLinesAsync(const Model::DeleteCustomLinesRequest& request, const DeleteCustomLinesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteCustomLinesOutcomeCallable deleteCustomLinesCallable(const Model::DeleteCustomLinesRequest& request) const;
@@ -943,6 +1049,39 @@ namespace AlibabaCloud
 			DescribeInstanceDomainsOutcome describeInstanceDomains(const Model::DescribeInstanceDomainsRequest &request)const;
 			void describeInstanceDomainsAsync(const Model::DescribeInstanceDomainsRequest& request, const DescribeInstanceDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeInstanceDomainsOutcomeCallable describeInstanceDomainsCallable(const Model::DescribeInstanceDomainsRequest& request) const;
+			DescribePdnsAccountSummaryOutcome describePdnsAccountSummary(const Model::DescribePdnsAccountSummaryRequest &request)const;
+			void describePdnsAccountSummaryAsync(const Model::DescribePdnsAccountSummaryRequest& request, const DescribePdnsAccountSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsAccountSummaryOutcomeCallable describePdnsAccountSummaryCallable(const Model::DescribePdnsAccountSummaryRequest& request) const;
+			DescribePdnsAppKeyOutcome describePdnsAppKey(const Model::DescribePdnsAppKeyRequest &request)const;
+			void describePdnsAppKeyAsync(const Model::DescribePdnsAppKeyRequest& request, const DescribePdnsAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsAppKeyOutcomeCallable describePdnsAppKeyCallable(const Model::DescribePdnsAppKeyRequest& request) const;
+			DescribePdnsAppKeysOutcome describePdnsAppKeys(const Model::DescribePdnsAppKeysRequest &request)const;
+			void describePdnsAppKeysAsync(const Model::DescribePdnsAppKeysRequest& request, const DescribePdnsAppKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsAppKeysOutcomeCallable describePdnsAppKeysCallable(const Model::DescribePdnsAppKeysRequest& request) const;
+			DescribePdnsOperateLogsOutcome describePdnsOperateLogs(const Model::DescribePdnsOperateLogsRequest &request)const;
+			void describePdnsOperateLogsAsync(const Model::DescribePdnsOperateLogsRequest& request, const DescribePdnsOperateLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsOperateLogsOutcomeCallable describePdnsOperateLogsCallable(const Model::DescribePdnsOperateLogsRequest& request) const;
+			DescribePdnsRequestStatisticOutcome describePdnsRequestStatistic(const Model::DescribePdnsRequestStatisticRequest &request)const;
+			void describePdnsRequestStatisticAsync(const Model::DescribePdnsRequestStatisticRequest& request, const DescribePdnsRequestStatisticAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsRequestStatisticOutcomeCallable describePdnsRequestStatisticCallable(const Model::DescribePdnsRequestStatisticRequest& request) const;
+			DescribePdnsRequestStatisticsOutcome describePdnsRequestStatistics(const Model::DescribePdnsRequestStatisticsRequest &request)const;
+			void describePdnsRequestStatisticsAsync(const Model::DescribePdnsRequestStatisticsRequest& request, const DescribePdnsRequestStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsRequestStatisticsOutcomeCallable describePdnsRequestStatisticsCallable(const Model::DescribePdnsRequestStatisticsRequest& request) const;
+			DescribePdnsThreatLogsOutcome describePdnsThreatLogs(const Model::DescribePdnsThreatLogsRequest &request)const;
+			void describePdnsThreatLogsAsync(const Model::DescribePdnsThreatLogsRequest& request, const DescribePdnsThreatLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsThreatLogsOutcomeCallable describePdnsThreatLogsCallable(const Model::DescribePdnsThreatLogsRequest& request) const;
+			DescribePdnsThreatStatisticOutcome describePdnsThreatStatistic(const Model::DescribePdnsThreatStatisticRequest &request)const;
+			void describePdnsThreatStatisticAsync(const Model::DescribePdnsThreatStatisticRequest& request, const DescribePdnsThreatStatisticAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsThreatStatisticOutcomeCallable describePdnsThreatStatisticCallable(const Model::DescribePdnsThreatStatisticRequest& request) const;
+			DescribePdnsThreatStatisticsOutcome describePdnsThreatStatistics(const Model::DescribePdnsThreatStatisticsRequest &request)const;
+			void describePdnsThreatStatisticsAsync(const Model::DescribePdnsThreatStatisticsRequest& request, const DescribePdnsThreatStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsThreatStatisticsOutcomeCallable describePdnsThreatStatisticsCallable(const Model::DescribePdnsThreatStatisticsRequest& request) const;
+			DescribePdnsUdpIpSegmentsOutcome describePdnsUdpIpSegments(const Model::DescribePdnsUdpIpSegmentsRequest &request)const;
+			void describePdnsUdpIpSegmentsAsync(const Model::DescribePdnsUdpIpSegmentsRequest& request, const DescribePdnsUdpIpSegmentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsUdpIpSegmentsOutcomeCallable describePdnsUdpIpSegmentsCallable(const Model::DescribePdnsUdpIpSegmentsRequest& request) const;
+			DescribePdnsUserInfoOutcome describePdnsUserInfo(const Model::DescribePdnsUserInfoRequest &request)const;
+			void describePdnsUserInfoAsync(const Model::DescribePdnsUserInfoRequest& request, const DescribePdnsUserInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePdnsUserInfoOutcomeCallable describePdnsUserInfoCallable(const Model::DescribePdnsUserInfoRequest& request) const;
 			DescribeRecordLogsOutcome describeRecordLogs(const Model::DescribeRecordLogsRequest &request)const;
 			void describeRecordLogsAsync(const Model::DescribeRecordLogsRequest& request, const DescribeRecordLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRecordLogsOutcomeCallable describeRecordLogsCallable(const Model::DescribeRecordLogsRequest& request) const;
@@ -988,9 +1127,21 @@ namespace AlibabaCloud
 			OperateBatchDomainOutcome operateBatchDomain(const Model::OperateBatchDomainRequest &request)const;
 			void operateBatchDomainAsync(const Model::OperateBatchDomainRequest& request, const OperateBatchDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			OperateBatchDomainOutcomeCallable operateBatchDomainCallable(const Model::OperateBatchDomainRequest& request) const;
+			PausePdnsServiceOutcome pausePdnsService(const Model::PausePdnsServiceRequest &request)const;
+			void pausePdnsServiceAsync(const Model::PausePdnsServiceRequest& request, const PausePdnsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PausePdnsServiceOutcomeCallable pausePdnsServiceCallable(const Model::PausePdnsServiceRequest& request) const;
 			PreviewGtmRecoveryPlanOutcome previewGtmRecoveryPlan(const Model::PreviewGtmRecoveryPlanRequest &request)const;
 			void previewGtmRecoveryPlanAsync(const Model::PreviewGtmRecoveryPlanRequest& request, const PreviewGtmRecoveryPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PreviewGtmRecoveryPlanOutcomeCallable previewGtmRecoveryPlanCallable(const Model::PreviewGtmRecoveryPlanRequest& request) const;
+			RemovePdnsAppKeyOutcome removePdnsAppKey(const Model::RemovePdnsAppKeyRequest &request)const;
+			void removePdnsAppKeyAsync(const Model::RemovePdnsAppKeyRequest& request, const RemovePdnsAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemovePdnsAppKeyOutcomeCallable removePdnsAppKeyCallable(const Model::RemovePdnsAppKeyRequest& request) const;
+			RemovePdnsUdpIpSegmentOutcome removePdnsUdpIpSegment(const Model::RemovePdnsUdpIpSegmentRequest &request)const;
+			void removePdnsUdpIpSegmentAsync(const Model::RemovePdnsUdpIpSegmentRequest& request, const RemovePdnsUdpIpSegmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemovePdnsUdpIpSegmentOutcomeCallable removePdnsUdpIpSegmentCallable(const Model::RemovePdnsUdpIpSegmentRequest& request) const;
+			ResumePdnsServiceOutcome resumePdnsService(const Model::ResumePdnsServiceRequest &request)const;
+			void resumePdnsServiceAsync(const Model::ResumePdnsServiceRequest& request, const ResumePdnsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ResumePdnsServiceOutcomeCallable resumePdnsServiceCallable(const Model::ResumePdnsServiceRequest& request) const;
 			RetrieveDomainOutcome retrieveDomain(const Model::RetrieveDomainRequest &request)const;
 			void retrieveDomainAsync(const Model::RetrieveDomainRequest& request, const RetrieveDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RetrieveDomainOutcomeCallable retrieveDomainCallable(const Model::RetrieveDomainRequest& request) const;
@@ -1033,6 +1184,9 @@ namespace AlibabaCloud
 			UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
 			void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
+			UpdateAppKeyStateOutcome updateAppKeyState(const Model::UpdateAppKeyStateRequest &request)const;
+			void updateAppKeyStateAsync(const Model::UpdateAppKeyStateRequest& request, const UpdateAppKeyStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAppKeyStateOutcomeCallable updateAppKeyStateCallable(const Model::UpdateAppKeyStateRequest& request) const;
 			UpdateCustomLineOutcome updateCustomLine(const Model::UpdateCustomLineRequest &request)const;
 			void updateCustomLineAsync(const Model::UpdateCustomLineRequest& request, const UpdateCustomLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateCustomLineOutcomeCallable updateCustomLineCallable(const Model::UpdateCustomLineRequest& request) const;
@@ -1084,6 +1238,12 @@ namespace AlibabaCloud
 			UpdateGtmRecoveryPlanOutcome updateGtmRecoveryPlan(const Model::UpdateGtmRecoveryPlanRequest &request)const;
 			void updateGtmRecoveryPlanAsync(const Model::UpdateGtmRecoveryPlanRequest& request, const UpdateGtmRecoveryPlanAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateGtmRecoveryPlanOutcomeCallable updateGtmRecoveryPlanCallable(const Model::UpdateGtmRecoveryPlanRequest& request) const;
+			ValidateDnsGtmCnameRrCanUseOutcome validateDnsGtmCnameRrCanUse(const Model::ValidateDnsGtmCnameRrCanUseRequest &request)const;
+			void validateDnsGtmCnameRrCanUseAsync(const Model::ValidateDnsGtmCnameRrCanUseRequest& request, const ValidateDnsGtmCnameRrCanUseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ValidateDnsGtmCnameRrCanUseOutcomeCallable validateDnsGtmCnameRrCanUseCallable(const Model::ValidateDnsGtmCnameRrCanUseRequest& request) const;
+			ValidatePdnsUdpIpSegmentOutcome validatePdnsUdpIpSegment(const Model::ValidatePdnsUdpIpSegmentRequest &request)const;
+			void validatePdnsUdpIpSegmentAsync(const Model::ValidatePdnsUdpIpSegmentRequest& request, const ValidatePdnsUdpIpSegmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ValidatePdnsUdpIpSegmentOutcomeCallable validatePdnsUdpIpSegmentCallable(const Model::ValidatePdnsUdpIpSegmentRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

alidns/include/alibabacloud/alidns/model/CreatePdnsAppKeyRequest.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_ALIDNS_MODEL_CREATEPDNSAPPKEYREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_CREATEPDNSAPPKEYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT CreatePdnsAppKeyRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreatePdnsAppKeyRequest();
+				~CreatePdnsAppKeyRequest();
+
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_CREATEPDNSAPPKEYREQUEST_H_

alidns/include/alibabacloud/alidns/model/CreatePdnsAppKeyResult.h

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

alidns/include/alibabacloud/alidns/model/CreatePdnsUdpIpSegmentRequest.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_ALIDNS_MODEL_CREATEPDNSUDPIPSEGMENTREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_CREATEPDNSUDPIPSEGMENTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT CreatePdnsUdpIpSegmentRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreatePdnsUdpIpSegmentRequest();
+				~CreatePdnsUdpIpSegmentRequest();
+
+				std::string getIp()const;
+				void setIp(const std::string& ip);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string ip_;
+				std::string name_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_CREATEPDNSUDPIPSEGMENTREQUEST_H_

alidns/include/alibabacloud/alidns/model/CreatePdnsUdpIpSegmentResult.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_ALIDNS_MODEL_CREATEPDNSUDPIPSEGMENTRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_CREATEPDNSUDPIPSEGMENTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT CreatePdnsUdpIpSegmentResult : public ServiceResult
+			{
+			public:
+
+
+				CreatePdnsUdpIpSegmentResult();
+				explicit CreatePdnsUdpIpSegmentResult(const std::string &payload);
+				~CreatePdnsUdpIpSegmentResult();
+				std::string getValidMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string validMessage_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_CREATEPDNSUDPIPSEGMENTRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribeDnsGtmInstanceResult.h

@@ -37,22 +37,25 @@ namespace AlibabaCloud
 					struct AlertConfigItem
 					{
 						bool emailNotice;
-						std::string noticeType;
 						bool smsNotice;
+						std::string noticeType;
+						bool dingtalkNotice;
 					};
 					std::string instanceName;
-					std::string pubicZoneName;
 					std::string alertGroup;
+					std::string pubicZoneName;
 					std::vector<AlertConfigItem> alertConfig;
 					std::string cnameType;
 					std::string publicUserDomainName;
 					std::string strategyMode;
+					std::string publicRr;
 					int ttl;
 					std::string publicCnameMode;
 				};
 				struct UsedQuota
 				{
 					int taskUsedCount;
+					int dingtalkUsedCount;
 					int smsUsedCount;
 					int emailUsedCount;
 				};
@@ -61,8 +64,8 @@ namespace AlibabaCloud
 				DescribeDnsGtmInstanceResult();
 				explicit DescribeDnsGtmInstanceResult(const std::string &payload);
 				~DescribeDnsGtmInstanceResult();
-				std::string getVersionCode()const;
 				long getExpireTimestamp()const;
+				std::string getVersionCode()const;
 				std::string getResourceGroupId()const;
 				std::string getInstanceId()const;
 				Config getConfig()const;
@@ -77,8 +80,8 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string versionCode_;
 				long expireTimestamp_;
+				std::string versionCode_;
 				std::string resourceGroupId_;
 				std::string instanceId_;
 				Config config_;

alidns/include/alibabacloud/alidns/model/DescribeDnsGtmInstancesResult.h

@@ -39,8 +39,9 @@ namespace AlibabaCloud
 						struct AlertConfigItem
 						{
 							std::string emailNotice;
-							std::string noticeType;
 							std::string smsNotice;
+							std::string noticeType;
+							std::string dingtalkNotice;
 						};
 						std::string instanceName;
 						std::string alertGroup;
@@ -49,17 +50,19 @@ namespace AlibabaCloud
 						std::string publicUserDomainName;
 						std::string publicZoneName;
 						std::string strategyMode;
+						std::string publicRr;
 						int ttl;
 						std::string publicCnameMode;
 					};
 					struct UsedQuota
 					{
 						int taskUsedCount;
+						int dingtalkUsedCount;
 						int smsUsedCount;
 						int emailUsedCount;
 					};
-					std::string versionCode;
 					long expireTimestamp;
+					std::string versionCode;
 					std::string resourceGroupId;
 					std::string instanceId;
 					Config config;

alidns/include/alibabacloud/alidns/model/DescribeGtmInstanceResult.h

@@ -40,11 +40,12 @@ namespace AlibabaCloud
 				long getExpireTimestamp()const;
 				std::string getUserDomainName()const;
 				std::string getLbaStrategy()const;
+				std::string getResourceGroupId()const;
 				std::string getInstanceId()const;
 				std::string getCreateTime()const;
 				std::string getCnameMode()const;
-				std::string getCname()const;
 				int getTtl()const;
+				std::string getCname()const;
 				std::string getInstanceName()const;
 				std::string getVersionCode()const;
 				std::string getAlertGroup()const;
@@ -59,11 +60,12 @@ namespace AlibabaCloud
 				long expireTimestamp_;
 				std::string userDomainName_;
 				std::string lbaStrategy_;
+				std::string resourceGroupId_;
 				std::string instanceId_;
 				std::string createTime_;
 				std::string cnameMode_;
-				std::string cname_;
 				int ttl_;
+				std::string cname_;
 				std::string instanceName_;
 				std::string versionCode_;
 				std::string alertGroup_;

alidns/include/alibabacloud/alidns/model/DescribeGtmInstancesResult.h

@@ -37,11 +37,12 @@ namespace AlibabaCloud
 					long expireTimestamp;
 					std::string userDomainName;
 					std::string lbaStrategy;
+					std::string resourceGroupId;
 					std::string instanceId;
 					std::string createTime;
 					std::string cnameMode;
-					std::string cname;
 					int ttl;
+					std::string cname;
 					std::string instanceName;
 					std::string versionCode;
 					std::string alertGroup;

alidns/include/alibabacloud/alidns/model/DescribePdnsAccountSummaryRequest.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_ALIDNS_MODEL_DESCRIBEPDNSACCOUNTSUMMARYREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSACCOUNTSUMMARYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsAccountSummaryRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsAccountSummaryRequest();
+				~DescribePdnsAccountSummaryRequest();
+
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string startDate_;
+				std::string endDate_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSACCOUNTSUMMARYREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsAccountSummaryResult.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_ALIDNS_MODEL_DESCRIBEPDNSACCOUNTSUMMARYRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSACCOUNTSUMMARYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsAccountSummaryResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					long totalCount;
+					long threatCount;
+					long userId;
+					long httpsCount;
+					long httpCount;
+					long subDomainCount;
+					long domainCount;
+				};
+
+
+				DescribePdnsAccountSummaryResult();
+				explicit DescribePdnsAccountSummaryResult(const std::string &payload);
+				~DescribePdnsAccountSummaryResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSACCOUNTSUMMARYRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsAppKeyRequest.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_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsAppKeyRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsAppKeyRequest();
+				~DescribePdnsAppKeyRequest();
+
+				std::string getAppKeyId()const;
+				void setAppKeyId(const std::string& appKeyId);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string appKeyId_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsAppKeyResult.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsAppKeyResult : public ServiceResult
+			{
+			public:
+				struct AppKey
+				{
+					std::string state;
+					std::string appKeyId;
+					std::string createDate;
+					std::string appKeySecret;
+				};
+
+
+				DescribePdnsAppKeyResult();
+				explicit DescribePdnsAppKeyResult(const std::string &payload);
+				~DescribePdnsAppKeyResult();
+				AppKey getAppKey()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				AppKey appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsAppKeysRequest.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_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYSREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsAppKeysRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsAppKeysRequest();
+				~DescribePdnsAppKeysRequest();
+
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYSREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsAppKeysResult.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYSRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsAppKeysResult : public ServiceResult
+			{
+			public:
+				struct AppKey
+				{
+					std::string state;
+					std::string appKeyId;
+					std::string createDate;
+				};
+
+
+				DescribePdnsAppKeysResult();
+				explicit DescribePdnsAppKeysResult(const std::string &payload);
+				~DescribePdnsAppKeysResult();
+				std::vector<AppKey> getAppKeys()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<AppKey> appKeys_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSAPPKEYSRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsOperateLogsRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_ALIDNS_MODEL_DESCRIBEPDNSOPERATELOGSREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSOPERATELOGSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsOperateLogsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsOperateLogsRequest();
+				~DescribePdnsOperateLogsRequest();
+
+				std::string getActionType()const;
+				void setActionType(const std::string& actionType);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+				std::string getKeyword()const;
+				void setKeyword(const std::string& keyword);
+
+            private:
+				std::string actionType_;
+				std::string startDate_;
+				long pageNumber_;
+				std::string endDate_;
+				long pageSize_;
+				std::string lang_;
+				std::string keyword_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSOPERATELOGSREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsOperateLogsResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSOPERATELOGSRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSOPERATELOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsOperateLogsResult : public ServiceResult
+			{
+			public:
+				struct Log
+				{
+					std::string operateTime;
+					std::string action;
+					std::string type;
+					std::string content;
+				};
+
+
+				DescribePdnsOperateLogsResult();
+				explicit DescribePdnsOperateLogsResult(const std::string &payload);
+				~DescribePdnsOperateLogsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<Log> getLogs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<Log> logs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSOPERATELOGSRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsRequestStatisticRequest.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_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsRequestStatisticRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsRequestStatisticRequest();
+				~DescribePdnsRequestStatisticRequest();
+
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				std::string getSubDomain()const;
+				void setSubDomain(const std::string& subDomain);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string domainName_;
+				std::string type_;
+				std::string startDate_;
+				std::string endDate_;
+				std::string subDomain_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsRequestStatisticResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsRequestStatisticResult : public ServiceResult
+			{
+			public:
+				struct StatisticItem
+				{
+					long udpTotalCount;
+					long ipCount;
+					long v6HttpCount;
+					long v4Count;
+					long httpsCount;
+					long v4HttpsCount;
+					long timestamp;
+					long v6Count;
+					long totalCount;
+					long v4HttpCount;
+					long httpCount;
+					long v6HttpsCount;
+					long dohTotalCount;
+				};
+
+
+				DescribePdnsRequestStatisticResult();
+				explicit DescribePdnsRequestStatisticResult(const std::string &payload);
+				~DescribePdnsRequestStatisticResult();
+				std::vector<StatisticItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<StatisticItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsRequestStatisticsRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICSREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsRequestStatisticsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsRequestStatisticsRequest();
+				~DescribePdnsRequestStatisticsRequest();
+
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				bool getNeedThreatInfo()const;
+				void setNeedThreatInfo(bool needThreatInfo);
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::string getSubDomain()const;
+				void setSubDomain(const std::string& subDomain);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string domainName_;
+				bool needThreatInfo_;
+				std::string type_;
+				std::string startDate_;
+				long pageNumber_;
+				std::string endDate_;
+				long pageSize_;
+				std::string subDomain_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICSREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsRequestStatisticsResult.h

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICSRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsRequestStatisticsResult : public ServiceResult
+			{
+			public:
+				struct StatisticItem
+				{
+					struct ThreatItem
+					{
+						std::string threatLevel;
+						std::string threatType;
+					};
+					long udpTotalCount;
+					long ipCount;
+					std::vector<StatisticItem::ThreatItem> threatInfo;
+					std::string domainName;
+					long v6HttpCount;
+					long v4Count;
+					long httpsCount;
+					long v4HttpsCount;
+					long v6Count;
+					std::string subDomain;
+					long totalCount;
+					long v4HttpCount;
+					long threatCount;
+					std::string maxThreatLevel;
+					long httpCount;
+					long v6HttpsCount;
+					long dohTotalCount;
+				};
+
+
+				DescribePdnsRequestStatisticsResult();
+				explicit DescribePdnsRequestStatisticsResult(const std::string &payload);
+				~DescribePdnsRequestStatisticsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<StatisticItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<StatisticItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSREQUESTSTATISTICSRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsThreatLogsRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATLOGSREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATLOGSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsThreatLogsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsThreatLogsRequest();
+				~DescribePdnsThreatLogsRequest();
+
+				std::string getThreatSourceIp()const;
+				void setThreatSourceIp(const std::string& threatSourceIp);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::string getThreatType()const;
+				void setThreatType(const std::string& threatType);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+				std::string getKeyword()const;
+				void setKeyword(const std::string& keyword);
+				std::string getThreatLevel()const;
+				void setThreatLevel(const std::string& threatLevel);
+
+            private:
+				std::string threatSourceIp_;
+				std::string startDate_;
+				long pageNumber_;
+				std::string endDate_;
+				long pageSize_;
+				std::string threatType_;
+				std::string lang_;
+				std::string keyword_;
+				std::string threatLevel_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATLOGSREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsThreatLogsResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATLOGSRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATLOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsThreatLogsResult : public ServiceResult
+			{
+			public:
+				struct Log
+				{
+					std::string subDomain;
+					std::string sourceIp;
+					std::string threatLevel;
+					std::string threatTime;
+					std::string threatType;
+				};
+
+
+				DescribePdnsThreatLogsResult();
+				explicit DescribePdnsThreatLogsResult(const std::string &payload);
+				~DescribePdnsThreatLogsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<Log> getLogs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<Log> logs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATLOGSRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsThreatStatisticRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsThreatStatisticRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsThreatStatisticRequest();
+				~DescribePdnsThreatStatisticRequest();
+
+				std::string getThreatSourceIp()const;
+				void setThreatSourceIp(const std::string& threatSourceIp);
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string threatSourceIp_;
+				std::string type_;
+				std::string startDate_;
+				std::string endDate_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsThreatStatisticResult.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsThreatStatisticResult : public ServiceResult
+			{
+			public:
+				struct StatisticItem
+				{
+					long udpTotalCount;
+					long totalCount;
+					std::string threatLevel;
+					std::string threatType;
+					long timestamp;
+					long dohTotalCount;
+				};
+
+
+				DescribePdnsThreatStatisticResult();
+				explicit DescribePdnsThreatStatisticResult(const std::string &payload);
+				~DescribePdnsThreatStatisticResult();
+				std::vector<StatisticItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<StatisticItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsThreatStatisticsRequest.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_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICSREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsThreatStatisticsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsThreatStatisticsRequest();
+				~DescribePdnsThreatStatisticsRequest();
+
+				std::string getType()const;
+				void setType(const std::string& type);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::string getThreatType()const;
+				void setThreatType(const std::string& threatType);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+				std::string getDirection()const;
+				void setDirection(const std::string& direction);
+				std::string getThreatSourceIp()const;
+				void setThreatSourceIp(const std::string& threatSourceIp);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getOrderBy()const;
+				void setOrderBy(const std::string& orderBy);
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				std::string getSubDomain()const;
+				void setSubDomain(const std::string& subDomain);
+				std::string getThreatLevel()const;
+				void setThreatLevel(const std::string& threatLevel);
+
+            private:
+				std::string type_;
+				std::string startDate_;
+				long pageNumber_;
+				long pageSize_;
+				std::string threatType_;
+				std::string lang_;
+				std::string direction_;
+				std::string threatSourceIp_;
+				std::string domainName_;
+				std::string orderBy_;
+				std::string endDate_;
+				std::string subDomain_;
+				std::string threatLevel_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICSREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsThreatStatisticsResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICSRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsThreatStatisticsResult : public ServiceResult
+			{
+			public:
+				struct StatisticItem
+				{
+					std::string subDomain;
+					long udpTotalCount;
+					long totalCount;
+					std::string sourceIp;
+					std::string threatLevel;
+					std::string domainName;
+					std::string threatType;
+					std::string maxThreatLevel;
+					long latestThreatTime;
+					long dohTotalCount;
+					long domainCount;
+				};
+
+
+				DescribePdnsThreatStatisticsResult();
+				explicit DescribePdnsThreatStatisticsResult(const std::string &payload);
+				~DescribePdnsThreatStatisticsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<StatisticItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<StatisticItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSTHREATSTATISTICSRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsUdpIpSegmentsRequest.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_ALIDNS_MODEL_DESCRIBEPDNSUDPIPSEGMENTSREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUDPIPSEGMENTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsUdpIpSegmentsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsUdpIpSegmentsRequest();
+				~DescribePdnsUdpIpSegmentsRequest();
+
+				long getPageNumber()const;
+				void setPageNumber(long pageNumber);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				long pageNumber_;
+				long pageSize_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUDPIPSEGMENTSREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsUdpIpSegmentsResult.h

@@ -0,0 +1,66 @@
+/*
+ * 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_ALIDNS_MODEL_DESCRIBEPDNSUDPIPSEGMENTSRESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUDPIPSEGMENTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsUdpIpSegmentsResult : public ServiceResult
+			{
+			public:
+				struct IpSegment
+				{
+					std::string updateDate;
+					std::string state;
+					std::string ip;
+					long mask;
+					std::string createDate;
+					std::string name;
+				};
+
+
+				DescribePdnsUdpIpSegmentsResult();
+				explicit DescribePdnsUdpIpSegmentsResult(const std::string &payload);
+				~DescribePdnsUdpIpSegmentsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<IpSegment> getIpSegments()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<IpSegment> ipSegments_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUDPIPSEGMENTSRESULT_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsUserInfoRequest.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_ALIDNS_MODEL_DESCRIBEPDNSUSERINFOREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUSERINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsUserInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribePdnsUserInfoRequest();
+				~DescribePdnsUserInfoRequest();
+
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUSERINFOREQUEST_H_

alidns/include/alibabacloud/alidns/model/DescribePdnsUserInfoResult.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_ALIDNS_MODEL_DESCRIBEPDNSUSERINFORESULT_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUSERINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT DescribePdnsUserInfoResult : public ServiceResult
+			{
+			public:
+				struct UserInfo
+				{
+					std::string availableService;
+					std::string serviceType;
+					std::string state;
+					std::string stoppedService;
+					long pdnsId;
+				};
+
+
+				DescribePdnsUserInfoResult();
+				explicit DescribePdnsUserInfoResult(const std::string &payload);
+				~DescribePdnsUserInfoResult();
+				UserInfo getUserInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				UserInfo userInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_DESCRIBEPDNSUSERINFORESULT_H_

alidns/include/alibabacloud/alidns/model/PausePdnsServiceRequest.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_ALIDNS_MODEL_PAUSEPDNSSERVICEREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_PAUSEPDNSSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT PausePdnsServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				PausePdnsServiceRequest();
+				~PausePdnsServiceRequest();
+
+				std::string getServiceType()const;
+				void setServiceType(const std::string& serviceType);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string serviceType_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_PAUSEPDNSSERVICEREQUEST_H_

alidns/include/alibabacloud/alidns/model/PausePdnsServiceResult.h

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

alidns/include/alibabacloud/alidns/model/RemovePdnsAppKeyRequest.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_ALIDNS_MODEL_REMOVEPDNSAPPKEYREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_REMOVEPDNSAPPKEYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT RemovePdnsAppKeyRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemovePdnsAppKeyRequest();
+				~RemovePdnsAppKeyRequest();
+
+				std::string getAppKeyId()const;
+				void setAppKeyId(const std::string& appKeyId);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string appKeyId_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_REMOVEPDNSAPPKEYREQUEST_H_

alidns/include/alibabacloud/alidns/model/RemovePdnsAppKeyResult.h

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

alidns/include/alibabacloud/alidns/model/RemovePdnsUdpIpSegmentRequest.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_ALIDNS_MODEL_REMOVEPDNSUDPIPSEGMENTREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_REMOVEPDNSUDPIPSEGMENTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT RemovePdnsUdpIpSegmentRequest : public RpcServiceRequest
+			{
+
+			public:
+				RemovePdnsUdpIpSegmentRequest();
+				~RemovePdnsUdpIpSegmentRequest();
+
+				std::string getIp()const;
+				void setIp(const std::string& ip);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string ip_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_REMOVEPDNSUDPIPSEGMENTREQUEST_H_

alidns/include/alibabacloud/alidns/model/RemovePdnsUdpIpSegmentResult.h

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

alidns/include/alibabacloud/alidns/model/ResumePdnsServiceRequest.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_ALIDNS_MODEL_RESUMEPDNSSERVICEREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_RESUMEPDNSSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT ResumePdnsServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				ResumePdnsServiceRequest();
+				~ResumePdnsServiceRequest();
+
+				std::string getServiceType()const;
+				void setServiceType(const std::string& serviceType);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string serviceType_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_RESUMEPDNSSERVICEREQUEST_H_

alidns/include/alibabacloud/alidns/model/ResumePdnsServiceResult.h

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

alidns/include/alibabacloud/alidns/model/UpdateAppKeyStateRequest.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_ALIDNS_MODEL_UPDATEAPPKEYSTATEREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_UPDATEAPPKEYSTATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT UpdateAppKeyStateRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateAppKeyStateRequest();
+				~UpdateAppKeyStateRequest();
+
+				std::string getAppKeyId()const;
+				void setAppKeyId(const std::string& appKeyId);
+				std::string getState()const;
+				void setState(const std::string& state);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string appKeyId_;
+				std::string state_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_UPDATEAPPKEYSTATEREQUEST_H_

alidns/include/alibabacloud/alidns/model/UpdateAppKeyStateResult.h

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

alidns/include/alibabacloud/alidns/model/UpdateDnsGtmAccessStrategyRequest.h

@@ -80,6 +80,8 @@ namespace AlibabaCloud
 				void setStrategyId(const std::string& strategyId);
 				std::vector<FailoverAddrPool> getFailoverAddrPool()const;
 				void setFailoverAddrPool(const std::vector<FailoverAddrPool>& failoverAddrPool);
+				std::string getAccessMode()const;
+				void setAccessMode(const std::string& accessMode);
 
             private:
 				std::string defaultLbaStrategy_;
@@ -99,6 +101,7 @@ namespace AlibabaCloud
 				std::string userClientIp_;
 				std::string strategyId_;
 				std::vector<FailoverAddrPool> failoverAddrPool_;
+				std::string accessMode_;
 
 			};
 		}

alidns/include/alibabacloud/alidns/model/UpdateDnsGtmInstanceGlobalConfigRequest.h

@@ -33,6 +33,7 @@ namespace AlibabaCloud
 			public:
 				struct AlertConfig
 				{
+					bool dingtalkNotice;
 					bool smsNotice;
 					std::string noticeType;
 					bool emailNotice;
@@ -56,10 +57,14 @@ namespace AlibabaCloud
 				void setPublicUserDomainName(const std::string& publicUserDomainName);
 				int getTtl()const;
 				void setTtl(int ttl);
+				bool getForceUpdate()const;
+				void setForceUpdate(bool forceUpdate);
 				std::string getInstanceId()const;
 				void setInstanceId(const std::string& instanceId);
 				std::string getInstanceName()const;
 				void setInstanceName(const std::string& instanceName);
+				std::string getPublicRr()const;
+				void setPublicRr(const std::string& publicRr);
 				std::string getUserClientIp()const;
 				void setUserClientIp(const std::string& userClientIp);
 				std::string getPublicZoneName()const;
@@ -73,8 +78,10 @@ namespace AlibabaCloud
 				std::string publicCnameMode_;
 				std::string publicUserDomainName_;
 				int ttl_;
+				bool forceUpdate_;
 				std::string instanceId_;
 				std::string instanceName_;
+				std::string publicRr_;
 				std::string userClientIp_;
 				std::string publicZoneName_;
 

alidns/include/alibabacloud/alidns/model/ValidateDnsGtmCnameRrCanUseRequest.h

@@ -0,0 +1,66 @@
+/*
+ * 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_ALIDNS_MODEL_VALIDATEDNSGTMCNAMERRCANUSEREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_VALIDATEDNSGTMCNAMERRCANUSEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT ValidateDnsGtmCnameRrCanUseRequest : public RpcServiceRequest
+			{
+
+			public:
+				ValidateDnsGtmCnameRrCanUseRequest();
+				~ValidateDnsGtmCnameRrCanUseRequest();
+
+				std::string getCnameMode()const;
+				void setCnameMode(const std::string& cnameMode);
+				std::string getCnameZone()const;
+				void setCnameZone(const std::string& cnameZone);
+				std::string getCnameRr()const;
+				void setCnameRr(const std::string& cnameRr);
+				std::string getCnameType()const;
+				void setCnameType(const std::string& cnameType);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getUserClientIp()const;
+				void setUserClientIp(const std::string& userClientIp);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string cnameMode_;
+				std::string cnameZone_;
+				std::string cnameRr_;
+				std::string cnameType_;
+				std::string instanceId_;
+				std::string userClientIp_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_VALIDATEDNSGTMCNAMERRCANUSEREQUEST_H_

alidns/include/alibabacloud/alidns/model/ValidateDnsGtmCnameRrCanUseResult.h

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

alidns/include/alibabacloud/alidns/model/ValidatePdnsUdpIpSegmentRequest.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_ALIDNS_MODEL_VALIDATEPDNSUDPIPSEGMENTREQUEST_H_
+#define ALIBABACLOUD_ALIDNS_MODEL_VALIDATEPDNSUDPIPSEGMENTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/alidns/AlidnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Alidns
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIDNS_EXPORT ValidatePdnsUdpIpSegmentRequest : public RpcServiceRequest
+			{
+
+			public:
+				ValidatePdnsUdpIpSegmentRequest();
+				~ValidatePdnsUdpIpSegmentRequest();
+
+				std::string getIp()const;
+				void setIp(const std::string& ip);
+				std::string getLang()const;
+				void setLang(const std::string& lang);
+
+            private:
+				std::string ip_;
+				std::string lang_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIDNS_MODEL_VALIDATEPDNSUDPIPSEGMENTREQUEST_H_

alidns/include/alibabacloud/alidns/model/ValidatePdnsUdpIpSegmentResult.h

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

alidns/src/AlidnsClient.cc

@@ -663,6 +663,78 @@ AlidnsClient::CopyGtmConfigOutcomeCallable AlidnsClient::copyGtmConfigCallable(c
 	return task->get_future();
 }
 
+AlidnsClient::CreatePdnsAppKeyOutcome AlidnsClient::createPdnsAppKey(const CreatePdnsAppKeyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePdnsAppKeyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePdnsAppKeyOutcome(CreatePdnsAppKeyResult(outcome.result()));
+	else
+		return CreatePdnsAppKeyOutcome(outcome.error());
+}
+
+void AlidnsClient::createPdnsAppKeyAsync(const CreatePdnsAppKeyRequest& request, const CreatePdnsAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPdnsAppKey(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::CreatePdnsAppKeyOutcomeCallable AlidnsClient::createPdnsAppKeyCallable(const CreatePdnsAppKeyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePdnsAppKeyOutcome()>>(
+			[this, request]()
+			{
+			return this->createPdnsAppKey(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::CreatePdnsUdpIpSegmentOutcome AlidnsClient::createPdnsUdpIpSegment(const CreatePdnsUdpIpSegmentRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePdnsUdpIpSegmentOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePdnsUdpIpSegmentOutcome(CreatePdnsUdpIpSegmentResult(outcome.result()));
+	else
+		return CreatePdnsUdpIpSegmentOutcome(outcome.error());
+}
+
+void AlidnsClient::createPdnsUdpIpSegmentAsync(const CreatePdnsUdpIpSegmentRequest& request, const CreatePdnsUdpIpSegmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPdnsUdpIpSegment(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::CreatePdnsUdpIpSegmentOutcomeCallable AlidnsClient::createPdnsUdpIpSegmentCallable(const CreatePdnsUdpIpSegmentRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePdnsUdpIpSegmentOutcome()>>(
+			[this, request]()
+			{
+			return this->createPdnsUdpIpSegment(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlidnsClient::DeleteCustomLinesOutcome AlidnsClient::deleteCustomLines(const DeleteCustomLinesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3075,6 +3147,402 @@ AlidnsClient::DescribeInstanceDomainsOutcomeCallable AlidnsClient::describeInsta
 	return task->get_future();
 }
 
+AlidnsClient::DescribePdnsAccountSummaryOutcome AlidnsClient::describePdnsAccountSummary(const DescribePdnsAccountSummaryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsAccountSummaryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsAccountSummaryOutcome(DescribePdnsAccountSummaryResult(outcome.result()));
+	else
+		return DescribePdnsAccountSummaryOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsAccountSummaryAsync(const DescribePdnsAccountSummaryRequest& request, const DescribePdnsAccountSummaryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsAccountSummary(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsAccountSummaryOutcomeCallable AlidnsClient::describePdnsAccountSummaryCallable(const DescribePdnsAccountSummaryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsAccountSummaryOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsAccountSummary(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsAppKeyOutcome AlidnsClient::describePdnsAppKey(const DescribePdnsAppKeyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsAppKeyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsAppKeyOutcome(DescribePdnsAppKeyResult(outcome.result()));
+	else
+		return DescribePdnsAppKeyOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsAppKeyAsync(const DescribePdnsAppKeyRequest& request, const DescribePdnsAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsAppKey(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsAppKeyOutcomeCallable AlidnsClient::describePdnsAppKeyCallable(const DescribePdnsAppKeyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsAppKeyOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsAppKey(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsAppKeysOutcome AlidnsClient::describePdnsAppKeys(const DescribePdnsAppKeysRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsAppKeysOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsAppKeysOutcome(DescribePdnsAppKeysResult(outcome.result()));
+	else
+		return DescribePdnsAppKeysOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsAppKeysAsync(const DescribePdnsAppKeysRequest& request, const DescribePdnsAppKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsAppKeys(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsAppKeysOutcomeCallable AlidnsClient::describePdnsAppKeysCallable(const DescribePdnsAppKeysRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsAppKeysOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsAppKeys(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsOperateLogsOutcome AlidnsClient::describePdnsOperateLogs(const DescribePdnsOperateLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsOperateLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsOperateLogsOutcome(DescribePdnsOperateLogsResult(outcome.result()));
+	else
+		return DescribePdnsOperateLogsOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsOperateLogsAsync(const DescribePdnsOperateLogsRequest& request, const DescribePdnsOperateLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsOperateLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsOperateLogsOutcomeCallable AlidnsClient::describePdnsOperateLogsCallable(const DescribePdnsOperateLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsOperateLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsOperateLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsRequestStatisticOutcome AlidnsClient::describePdnsRequestStatistic(const DescribePdnsRequestStatisticRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsRequestStatisticOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsRequestStatisticOutcome(DescribePdnsRequestStatisticResult(outcome.result()));
+	else
+		return DescribePdnsRequestStatisticOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsRequestStatisticAsync(const DescribePdnsRequestStatisticRequest& request, const DescribePdnsRequestStatisticAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsRequestStatistic(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsRequestStatisticOutcomeCallable AlidnsClient::describePdnsRequestStatisticCallable(const DescribePdnsRequestStatisticRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsRequestStatisticOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsRequestStatistic(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsRequestStatisticsOutcome AlidnsClient::describePdnsRequestStatistics(const DescribePdnsRequestStatisticsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsRequestStatisticsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsRequestStatisticsOutcome(DescribePdnsRequestStatisticsResult(outcome.result()));
+	else
+		return DescribePdnsRequestStatisticsOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsRequestStatisticsAsync(const DescribePdnsRequestStatisticsRequest& request, const DescribePdnsRequestStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsRequestStatistics(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsRequestStatisticsOutcomeCallable AlidnsClient::describePdnsRequestStatisticsCallable(const DescribePdnsRequestStatisticsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsRequestStatisticsOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsRequestStatistics(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsThreatLogsOutcome AlidnsClient::describePdnsThreatLogs(const DescribePdnsThreatLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsThreatLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsThreatLogsOutcome(DescribePdnsThreatLogsResult(outcome.result()));
+	else
+		return DescribePdnsThreatLogsOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsThreatLogsAsync(const DescribePdnsThreatLogsRequest& request, const DescribePdnsThreatLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsThreatLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsThreatLogsOutcomeCallable AlidnsClient::describePdnsThreatLogsCallable(const DescribePdnsThreatLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsThreatLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsThreatLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsThreatStatisticOutcome AlidnsClient::describePdnsThreatStatistic(const DescribePdnsThreatStatisticRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsThreatStatisticOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsThreatStatisticOutcome(DescribePdnsThreatStatisticResult(outcome.result()));
+	else
+		return DescribePdnsThreatStatisticOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsThreatStatisticAsync(const DescribePdnsThreatStatisticRequest& request, const DescribePdnsThreatStatisticAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsThreatStatistic(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsThreatStatisticOutcomeCallable AlidnsClient::describePdnsThreatStatisticCallable(const DescribePdnsThreatStatisticRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsThreatStatisticOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsThreatStatistic(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsThreatStatisticsOutcome AlidnsClient::describePdnsThreatStatistics(const DescribePdnsThreatStatisticsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsThreatStatisticsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsThreatStatisticsOutcome(DescribePdnsThreatStatisticsResult(outcome.result()));
+	else
+		return DescribePdnsThreatStatisticsOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsThreatStatisticsAsync(const DescribePdnsThreatStatisticsRequest& request, const DescribePdnsThreatStatisticsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsThreatStatistics(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsThreatStatisticsOutcomeCallable AlidnsClient::describePdnsThreatStatisticsCallable(const DescribePdnsThreatStatisticsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsThreatStatisticsOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsThreatStatistics(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsUdpIpSegmentsOutcome AlidnsClient::describePdnsUdpIpSegments(const DescribePdnsUdpIpSegmentsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsUdpIpSegmentsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsUdpIpSegmentsOutcome(DescribePdnsUdpIpSegmentsResult(outcome.result()));
+	else
+		return DescribePdnsUdpIpSegmentsOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsUdpIpSegmentsAsync(const DescribePdnsUdpIpSegmentsRequest& request, const DescribePdnsUdpIpSegmentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsUdpIpSegments(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsUdpIpSegmentsOutcomeCallable AlidnsClient::describePdnsUdpIpSegmentsCallable(const DescribePdnsUdpIpSegmentsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsUdpIpSegmentsOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsUdpIpSegments(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::DescribePdnsUserInfoOutcome AlidnsClient::describePdnsUserInfo(const DescribePdnsUserInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePdnsUserInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePdnsUserInfoOutcome(DescribePdnsUserInfoResult(outcome.result()));
+	else
+		return DescribePdnsUserInfoOutcome(outcome.error());
+}
+
+void AlidnsClient::describePdnsUserInfoAsync(const DescribePdnsUserInfoRequest& request, const DescribePdnsUserInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePdnsUserInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::DescribePdnsUserInfoOutcomeCallable AlidnsClient::describePdnsUserInfoCallable(const DescribePdnsUserInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePdnsUserInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describePdnsUserInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlidnsClient::DescribeRecordLogsOutcome AlidnsClient::describeRecordLogs(const DescribeRecordLogsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3615,6 +4083,42 @@ AlidnsClient::OperateBatchDomainOutcomeCallable AlidnsClient::operateBatchDomain
 	return task->get_future();
 }
 
+AlidnsClient::PausePdnsServiceOutcome AlidnsClient::pausePdnsService(const PausePdnsServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PausePdnsServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PausePdnsServiceOutcome(PausePdnsServiceResult(outcome.result()));
+	else
+		return PausePdnsServiceOutcome(outcome.error());
+}
+
+void AlidnsClient::pausePdnsServiceAsync(const PausePdnsServiceRequest& request, const PausePdnsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pausePdnsService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::PausePdnsServiceOutcomeCallable AlidnsClient::pausePdnsServiceCallable(const PausePdnsServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PausePdnsServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->pausePdnsService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlidnsClient::PreviewGtmRecoveryPlanOutcome AlidnsClient::previewGtmRecoveryPlan(const PreviewGtmRecoveryPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3651,6 +4155,114 @@ AlidnsClient::PreviewGtmRecoveryPlanOutcomeCallable AlidnsClient::previewGtmReco
 	return task->get_future();
 }
 
+AlidnsClient::RemovePdnsAppKeyOutcome AlidnsClient::removePdnsAppKey(const RemovePdnsAppKeyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemovePdnsAppKeyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemovePdnsAppKeyOutcome(RemovePdnsAppKeyResult(outcome.result()));
+	else
+		return RemovePdnsAppKeyOutcome(outcome.error());
+}
+
+void AlidnsClient::removePdnsAppKeyAsync(const RemovePdnsAppKeyRequest& request, const RemovePdnsAppKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removePdnsAppKey(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::RemovePdnsAppKeyOutcomeCallable AlidnsClient::removePdnsAppKeyCallable(const RemovePdnsAppKeyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemovePdnsAppKeyOutcome()>>(
+			[this, request]()
+			{
+			return this->removePdnsAppKey(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::RemovePdnsUdpIpSegmentOutcome AlidnsClient::removePdnsUdpIpSegment(const RemovePdnsUdpIpSegmentRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemovePdnsUdpIpSegmentOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemovePdnsUdpIpSegmentOutcome(RemovePdnsUdpIpSegmentResult(outcome.result()));
+	else
+		return RemovePdnsUdpIpSegmentOutcome(outcome.error());
+}
+
+void AlidnsClient::removePdnsUdpIpSegmentAsync(const RemovePdnsUdpIpSegmentRequest& request, const RemovePdnsUdpIpSegmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removePdnsUdpIpSegment(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::RemovePdnsUdpIpSegmentOutcomeCallable AlidnsClient::removePdnsUdpIpSegmentCallable(const RemovePdnsUdpIpSegmentRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemovePdnsUdpIpSegmentOutcome()>>(
+			[this, request]()
+			{
+			return this->removePdnsUdpIpSegment(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::ResumePdnsServiceOutcome AlidnsClient::resumePdnsService(const ResumePdnsServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResumePdnsServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResumePdnsServiceOutcome(ResumePdnsServiceResult(outcome.result()));
+	else
+		return ResumePdnsServiceOutcome(outcome.error());
+}
+
+void AlidnsClient::resumePdnsServiceAsync(const ResumePdnsServiceRequest& request, const ResumePdnsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resumePdnsService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::ResumePdnsServiceOutcomeCallable AlidnsClient::resumePdnsServiceCallable(const ResumePdnsServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResumePdnsServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->resumePdnsService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlidnsClient::RetrieveDomainOutcome AlidnsClient::retrieveDomain(const RetrieveDomainRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4155,6 +4767,42 @@ AlidnsClient::UntagResourcesOutcomeCallable AlidnsClient::untagResourcesCallable
 	return task->get_future();
 }
 
+AlidnsClient::UpdateAppKeyStateOutcome AlidnsClient::updateAppKeyState(const UpdateAppKeyStateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAppKeyStateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAppKeyStateOutcome(UpdateAppKeyStateResult(outcome.result()));
+	else
+		return UpdateAppKeyStateOutcome(outcome.error());
+}
+
+void AlidnsClient::updateAppKeyStateAsync(const UpdateAppKeyStateRequest& request, const UpdateAppKeyStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAppKeyState(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::UpdateAppKeyStateOutcomeCallable AlidnsClient::updateAppKeyStateCallable(const UpdateAppKeyStateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAppKeyStateOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAppKeyState(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AlidnsClient::UpdateCustomLineOutcome AlidnsClient::updateCustomLine(const UpdateCustomLineRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4767,3 +5415,75 @@ AlidnsClient::UpdateGtmRecoveryPlanOutcomeCallable AlidnsClient::updateGtmRecove
 	return task->get_future();
 }
 
+AlidnsClient::ValidateDnsGtmCnameRrCanUseOutcome AlidnsClient::validateDnsGtmCnameRrCanUse(const ValidateDnsGtmCnameRrCanUseRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ValidateDnsGtmCnameRrCanUseOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ValidateDnsGtmCnameRrCanUseOutcome(ValidateDnsGtmCnameRrCanUseResult(outcome.result()));
+	else
+		return ValidateDnsGtmCnameRrCanUseOutcome(outcome.error());
+}
+
+void AlidnsClient::validateDnsGtmCnameRrCanUseAsync(const ValidateDnsGtmCnameRrCanUseRequest& request, const ValidateDnsGtmCnameRrCanUseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, validateDnsGtmCnameRrCanUse(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::ValidateDnsGtmCnameRrCanUseOutcomeCallable AlidnsClient::validateDnsGtmCnameRrCanUseCallable(const ValidateDnsGtmCnameRrCanUseRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ValidateDnsGtmCnameRrCanUseOutcome()>>(
+			[this, request]()
+			{
+			return this->validateDnsGtmCnameRrCanUse(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AlidnsClient::ValidatePdnsUdpIpSegmentOutcome AlidnsClient::validatePdnsUdpIpSegment(const ValidatePdnsUdpIpSegmentRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ValidatePdnsUdpIpSegmentOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ValidatePdnsUdpIpSegmentOutcome(ValidatePdnsUdpIpSegmentResult(outcome.result()));
+	else
+		return ValidatePdnsUdpIpSegmentOutcome(outcome.error());
+}
+
+void AlidnsClient::validatePdnsUdpIpSegmentAsync(const ValidatePdnsUdpIpSegmentRequest& request, const ValidatePdnsUdpIpSegmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, validatePdnsUdpIpSegment(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AlidnsClient::ValidatePdnsUdpIpSegmentOutcomeCallable AlidnsClient::validatePdnsUdpIpSegmentCallable(const ValidatePdnsUdpIpSegmentRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ValidatePdnsUdpIpSegmentOutcome()>>(
+			[this, request]()
+			{
+			return this->validatePdnsUdpIpSegment(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

alidns/src/model/CreatePdnsAppKeyRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alidns/model/CreatePdnsAppKeyRequest.h>
+
+using AlibabaCloud::Alidns::Model::CreatePdnsAppKeyRequest;
+
+CreatePdnsAppKeyRequest::CreatePdnsAppKeyRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "CreatePdnsAppKey")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreatePdnsAppKeyRequest::~CreatePdnsAppKeyRequest()
+{}
+
+std::string CreatePdnsAppKeyRequest::getLang()const
+{
+	return lang_;
+}
+
+void CreatePdnsAppKeyRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/CreatePdnsAppKeyResult.cc

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

alidns/src/model/CreatePdnsUdpIpSegmentRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alidns/model/CreatePdnsUdpIpSegmentRequest.h>
+
+using AlibabaCloud::Alidns::Model::CreatePdnsUdpIpSegmentRequest;
+
+CreatePdnsUdpIpSegmentRequest::CreatePdnsUdpIpSegmentRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "CreatePdnsUdpIpSegment")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreatePdnsUdpIpSegmentRequest::~CreatePdnsUdpIpSegmentRequest()
+{}
+
+std::string CreatePdnsUdpIpSegmentRequest::getIp()const
+{
+	return ip_;
+}
+
+void CreatePdnsUdpIpSegmentRequest::setIp(const std::string& ip)
+{
+	ip_ = ip;
+	setParameter("Ip", ip);
+}
+
+std::string CreatePdnsUdpIpSegmentRequest::getName()const
+{
+	return name_;
+}
+
+void CreatePdnsUdpIpSegmentRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string CreatePdnsUdpIpSegmentRequest::getLang()const
+{
+	return lang_;
+}
+
+void CreatePdnsUdpIpSegmentRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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