Support SLB latest OpenAPIs.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-12-22 Version: patch
+- Support SLB latest OpenAPIs.
+
 2020-12-22 Version: patch
 - Release InterpolateVideoFrame ToneSdrVideo ConvertHdrVideo.
 

slb/CMakeLists.txt

@@ -47,10 +47,10 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h
 	include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h
 	include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h
-	include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h
-	include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h
 	include/alibabacloud/slb/model/CreateRulesRequest.h
 	include/alibabacloud/slb/model/CreateRulesResult.h
+	include/alibabacloud/slb/model/CreateTLSCipherPolicyRequest.h
+	include/alibabacloud/slb/model/CreateTLSCipherPolicyResult.h
 	include/alibabacloud/slb/model/CreateVServerGroupRequest.h
 	include/alibabacloud/slb/model/CreateVServerGroupResult.h
 	include/alibabacloud/slb/model/DeleteAccessControlListRequest.h
@@ -65,12 +65,12 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h
 	include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h
 	include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h
-	include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h
-	include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h
 	include/alibabacloud/slb/model/DeleteRulesRequest.h
 	include/alibabacloud/slb/model/DeleteRulesResult.h
 	include/alibabacloud/slb/model/DeleteServerCertificateRequest.h
 	include/alibabacloud/slb/model/DeleteServerCertificateResult.h
+	include/alibabacloud/slb/model/DeleteTLSCipherPolicyRequest.h
+	include/alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h
 	include/alibabacloud/slb/model/DeleteVServerGroupRequest.h
 	include/alibabacloud/slb/model/DeleteVServerGroupResult.h
 	include/alibabacloud/slb/model/DescribeAccessControlListAttributeRequest.h
@@ -95,8 +95,6 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h
 	include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h
 	include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h
-	include/alibabacloud/slb/model/DescribeLoadBalancerListenersExRequest.h
-	include/alibabacloud/slb/model/DescribeLoadBalancerListenersExResult.h
 	include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h
 	include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h
 	include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h
@@ -107,10 +105,6 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h
 	include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h
 	include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h
-	include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h
-	include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h
-	include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h
-	include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h
 	include/alibabacloud/slb/model/DescribeRegionsRequest.h
 	include/alibabacloud/slb/model/DescribeRegionsResult.h
 	include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h
@@ -127,6 +121,8 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/DescribeVServerGroupsResult.h
 	include/alibabacloud/slb/model/DescribeZonesRequest.h
 	include/alibabacloud/slb/model/DescribeZonesResult.h
+	include/alibabacloud/slb/model/ListTLSCipherPoliciesRequest.h
+	include/alibabacloud/slb/model/ListTLSCipherPoliciesResult.h
 	include/alibabacloud/slb/model/ListTagResourcesRequest.h
 	include/alibabacloud/slb/model/ListTagResourcesResult.h
 	include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h
@@ -163,8 +159,8 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h
 	include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h
 	include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h
-	include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExRequest.h
-	include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h
+	include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionRequest.h
+	include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h
 	include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h
 	include/alibabacloud/slb/model/SetLoadBalancerNameResult.h
 	include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h
@@ -177,6 +173,8 @@ set(slb_public_header_model
 	include/alibabacloud/slb/model/SetRuleResult.h
 	include/alibabacloud/slb/model/SetServerCertificateNameRequest.h
 	include/alibabacloud/slb/model/SetServerCertificateNameResult.h
+	include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeRequest.h
+	include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeResult.h
 	include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h
 	include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h
 	include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h
@@ -220,10 +218,10 @@ set(slb_src
 	src/model/CreateLoadBalancerUDPListenerResult.cc
 	src/model/CreateMasterSlaveServerGroupRequest.cc
 	src/model/CreateMasterSlaveServerGroupResult.cc
-	src/model/CreateMasterSlaveVServerGroupRequest.cc
-	src/model/CreateMasterSlaveVServerGroupResult.cc
 	src/model/CreateRulesRequest.cc
 	src/model/CreateRulesResult.cc
+	src/model/CreateTLSCipherPolicyRequest.cc
+	src/model/CreateTLSCipherPolicyResult.cc
 	src/model/CreateVServerGroupRequest.cc
 	src/model/CreateVServerGroupResult.cc
 	src/model/DeleteAccessControlListRequest.cc
@@ -238,12 +236,12 @@ set(slb_src
 	src/model/DeleteLoadBalancerListenerResult.cc
 	src/model/DeleteMasterSlaveServerGroupRequest.cc
 	src/model/DeleteMasterSlaveServerGroupResult.cc
-	src/model/DeleteMasterSlaveVServerGroupRequest.cc
-	src/model/DeleteMasterSlaveVServerGroupResult.cc
 	src/model/DeleteRulesRequest.cc
 	src/model/DeleteRulesResult.cc
 	src/model/DeleteServerCertificateRequest.cc
 	src/model/DeleteServerCertificateResult.cc
+	src/model/DeleteTLSCipherPolicyRequest.cc
+	src/model/DeleteTLSCipherPolicyResult.cc
 	src/model/DeleteVServerGroupRequest.cc
 	src/model/DeleteVServerGroupResult.cc
 	src/model/DescribeAccessControlListAttributeRequest.cc
@@ -268,8 +266,6 @@ set(slb_src
 	src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc
 	src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc
 	src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
-	src/model/DescribeLoadBalancerListenersExRequest.cc
-	src/model/DescribeLoadBalancerListenersExResult.cc
 	src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc
 	src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc
 	src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc
@@ -280,10 +276,6 @@ set(slb_src
 	src/model/DescribeMasterSlaveServerGroupAttributeResult.cc
 	src/model/DescribeMasterSlaveServerGroupsRequest.cc
 	src/model/DescribeMasterSlaveServerGroupsResult.cc
-	src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc
-	src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc
-	src/model/DescribeMasterSlaveVServerGroupsRequest.cc
-	src/model/DescribeMasterSlaveVServerGroupsResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeRuleAttributeRequest.cc
@@ -300,6 +292,8 @@ set(slb_src
 	src/model/DescribeVServerGroupsResult.cc
 	src/model/DescribeZonesRequest.cc
 	src/model/DescribeZonesResult.cc
+	src/model/ListTLSCipherPoliciesRequest.cc
+	src/model/ListTLSCipherPoliciesResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
 	src/model/ModifyLoadBalancerInstanceSpecRequest.cc
@@ -336,8 +330,8 @@ set(slb_src
 	src/model/SetLoadBalancerHTTPListenerAttributeResult.cc
 	src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc
 	src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc
-	src/model/SetLoadBalancerListenerAttributeExRequest.cc
-	src/model/SetLoadBalancerListenerAttributeExResult.cc
+	src/model/SetLoadBalancerModificationProtectionRequest.cc
+	src/model/SetLoadBalancerModificationProtectionResult.cc
 	src/model/SetLoadBalancerNameRequest.cc
 	src/model/SetLoadBalancerNameResult.cc
 	src/model/SetLoadBalancerStatusRequest.cc
@@ -350,6 +344,8 @@ set(slb_src
 	src/model/SetRuleResult.cc
 	src/model/SetServerCertificateNameRequest.cc
 	src/model/SetServerCertificateNameResult.cc
+	src/model/SetTLSCipherPolicyAttributeRequest.cc
+	src/model/SetTLSCipherPolicyAttributeResult.cc
 	src/model/SetVServerGroupAttributeRequest.cc
 	src/model/SetVServerGroupAttributeResult.cc
 	src/model/StartLoadBalancerListenerRequest.cc

slb/include/alibabacloud/slb/SlbClient.h

@@ -48,10 +48,10 @@
 #include "model/CreateLoadBalancerUDPListenerResult.h"
 #include "model/CreateMasterSlaveServerGroupRequest.h"
 #include "model/CreateMasterSlaveServerGroupResult.h"
-#include "model/CreateMasterSlaveVServerGroupRequest.h"
-#include "model/CreateMasterSlaveVServerGroupResult.h"
 #include "model/CreateRulesRequest.h"
 #include "model/CreateRulesResult.h"
+#include "model/CreateTLSCipherPolicyRequest.h"
+#include "model/CreateTLSCipherPolicyResult.h"
 #include "model/CreateVServerGroupRequest.h"
 #include "model/CreateVServerGroupResult.h"
 #include "model/DeleteAccessControlListRequest.h"
@@ -66,12 +66,12 @@
 #include "model/DeleteLoadBalancerListenerResult.h"
 #include "model/DeleteMasterSlaveServerGroupRequest.h"
 #include "model/DeleteMasterSlaveServerGroupResult.h"
-#include "model/DeleteMasterSlaveVServerGroupRequest.h"
-#include "model/DeleteMasterSlaveVServerGroupResult.h"
 #include "model/DeleteRulesRequest.h"
 #include "model/DeleteRulesResult.h"
 #include "model/DeleteServerCertificateRequest.h"
 #include "model/DeleteServerCertificateResult.h"
+#include "model/DeleteTLSCipherPolicyRequest.h"
+#include "model/DeleteTLSCipherPolicyResult.h"
 #include "model/DeleteVServerGroupRequest.h"
 #include "model/DeleteVServerGroupResult.h"
 #include "model/DescribeAccessControlListAttributeRequest.h"
@@ -96,8 +96,6 @@
 #include "model/DescribeLoadBalancerHTTPListenerAttributeResult.h"
 #include "model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h"
 #include "model/DescribeLoadBalancerHTTPSListenerAttributeResult.h"
-#include "model/DescribeLoadBalancerListenersExRequest.h"
-#include "model/DescribeLoadBalancerListenersExResult.h"
 #include "model/DescribeLoadBalancerTCPListenerAttributeRequest.h"
 #include "model/DescribeLoadBalancerTCPListenerAttributeResult.h"
 #include "model/DescribeLoadBalancerUDPListenerAttributeRequest.h"
@@ -108,10 +106,6 @@
 #include "model/DescribeMasterSlaveServerGroupAttributeResult.h"
 #include "model/DescribeMasterSlaveServerGroupsRequest.h"
 #include "model/DescribeMasterSlaveServerGroupsResult.h"
-#include "model/DescribeMasterSlaveVServerGroupAttributeRequest.h"
-#include "model/DescribeMasterSlaveVServerGroupAttributeResult.h"
-#include "model/DescribeMasterSlaveVServerGroupsRequest.h"
-#include "model/DescribeMasterSlaveVServerGroupsResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
 #include "model/DescribeRuleAttributeRequest.h"
@@ -128,6 +122,8 @@
 #include "model/DescribeVServerGroupsResult.h"
 #include "model/DescribeZonesRequest.h"
 #include "model/DescribeZonesResult.h"
+#include "model/ListTLSCipherPoliciesRequest.h"
+#include "model/ListTLSCipherPoliciesResult.h"
 #include "model/ListTagResourcesRequest.h"
 #include "model/ListTagResourcesResult.h"
 #include "model/ModifyLoadBalancerInstanceSpecRequest.h"
@@ -164,8 +160,8 @@
 #include "model/SetLoadBalancerHTTPListenerAttributeResult.h"
 #include "model/SetLoadBalancerHTTPSListenerAttributeRequest.h"
 #include "model/SetLoadBalancerHTTPSListenerAttributeResult.h"
-#include "model/SetLoadBalancerListenerAttributeExRequest.h"
-#include "model/SetLoadBalancerListenerAttributeExResult.h"
+#include "model/SetLoadBalancerModificationProtectionRequest.h"
+#include "model/SetLoadBalancerModificationProtectionResult.h"
 #include "model/SetLoadBalancerNameRequest.h"
 #include "model/SetLoadBalancerNameResult.h"
 #include "model/SetLoadBalancerStatusRequest.h"
@@ -178,6 +174,8 @@
 #include "model/SetRuleResult.h"
 #include "model/SetServerCertificateNameRequest.h"
 #include "model/SetServerCertificateNameResult.h"
+#include "model/SetTLSCipherPolicyAttributeRequest.h"
+#include "model/SetTLSCipherPolicyAttributeResult.h"
 #include "model/SetVServerGroupAttributeRequest.h"
 #include "model/SetVServerGroupAttributeResult.h"
 #include "model/StartLoadBalancerListenerRequest.h"
@@ -240,12 +238,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateMasterSlaveServerGroupResult> CreateMasterSlaveServerGroupOutcome;
 			typedef std::future<CreateMasterSlaveServerGroupOutcome> CreateMasterSlaveServerGroupOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::CreateMasterSlaveServerGroupRequest&, const CreateMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMasterSlaveServerGroupAsyncHandler;
-			typedef Outcome<Error, Model::CreateMasterSlaveVServerGroupResult> CreateMasterSlaveVServerGroupOutcome;
-			typedef std::future<CreateMasterSlaveVServerGroupOutcome> CreateMasterSlaveVServerGroupOutcomeCallable;
-			typedef std::function<void(const SlbClient*, const Model::CreateMasterSlaveVServerGroupRequest&, const CreateMasterSlaveVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMasterSlaveVServerGroupAsyncHandler;
 			typedef Outcome<Error, Model::CreateRulesResult> CreateRulesOutcome;
 			typedef std::future<CreateRulesOutcome> CreateRulesOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::CreateRulesRequest&, const CreateRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRulesAsyncHandler;
+			typedef Outcome<Error, Model::CreateTLSCipherPolicyResult> CreateTLSCipherPolicyOutcome;
+			typedef std::future<CreateTLSCipherPolicyOutcome> CreateTLSCipherPolicyOutcomeCallable;
+			typedef std::function<void(const SlbClient*, const Model::CreateTLSCipherPolicyRequest&, const CreateTLSCipherPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTLSCipherPolicyAsyncHandler;
 			typedef Outcome<Error, Model::CreateVServerGroupResult> CreateVServerGroupOutcome;
 			typedef std::future<CreateVServerGroupOutcome> CreateVServerGroupOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::CreateVServerGroupRequest&, const CreateVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVServerGroupAsyncHandler;
@@ -267,15 +265,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteMasterSlaveServerGroupResult> DeleteMasterSlaveServerGroupOutcome;
 			typedef std::future<DeleteMasterSlaveServerGroupOutcome> DeleteMasterSlaveServerGroupOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveServerGroupRequest&, const DeleteMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveServerGroupAsyncHandler;
-			typedef Outcome<Error, Model::DeleteMasterSlaveVServerGroupResult> DeleteMasterSlaveVServerGroupOutcome;
-			typedef std::future<DeleteMasterSlaveVServerGroupOutcome> DeleteMasterSlaveVServerGroupOutcomeCallable;
-			typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveVServerGroupRequest&, const DeleteMasterSlaveVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveVServerGroupAsyncHandler;
 			typedef Outcome<Error, Model::DeleteRulesResult> DeleteRulesOutcome;
 			typedef std::future<DeleteRulesOutcome> DeleteRulesOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DeleteRulesRequest&, const DeleteRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRulesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteServerCertificateResult> DeleteServerCertificateOutcome;
 			typedef std::future<DeleteServerCertificateOutcome> DeleteServerCertificateOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DeleteServerCertificateRequest&, const DeleteServerCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServerCertificateAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTLSCipherPolicyResult> DeleteTLSCipherPolicyOutcome;
+			typedef std::future<DeleteTLSCipherPolicyOutcome> DeleteTLSCipherPolicyOutcomeCallable;
+			typedef std::function<void(const SlbClient*, const Model::DeleteTLSCipherPolicyRequest&, const DeleteTLSCipherPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTLSCipherPolicyAsyncHandler;
 			typedef Outcome<Error, Model::DeleteVServerGroupResult> DeleteVServerGroupOutcome;
 			typedef std::future<DeleteVServerGroupOutcome> DeleteVServerGroupOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DeleteVServerGroupRequest&, const DeleteVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVServerGroupAsyncHandler;
@@ -312,9 +310,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeLoadBalancerHTTPSListenerAttributeResult> DescribeLoadBalancerHTTPSListenerAttributeOutcome;
 			typedef std::future<DescribeLoadBalancerHTTPSListenerAttributeOutcome> DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest&, const DescribeLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler;
-			typedef Outcome<Error, Model::DescribeLoadBalancerListenersExResult> DescribeLoadBalancerListenersExOutcome;
-			typedef std::future<DescribeLoadBalancerListenersExOutcome> DescribeLoadBalancerListenersExOutcomeCallable;
-			typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerListenersExRequest&, const DescribeLoadBalancerListenersExOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerListenersExAsyncHandler;
 			typedef Outcome<Error, Model::DescribeLoadBalancerTCPListenerAttributeResult> DescribeLoadBalancerTCPListenerAttributeOutcome;
 			typedef std::future<DescribeLoadBalancerTCPListenerAttributeOutcome> DescribeLoadBalancerTCPListenerAttributeOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerTCPListenerAttributeRequest&, const DescribeLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerTCPListenerAttributeAsyncHandler;
@@ -330,12 +325,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeMasterSlaveServerGroupsResult> DescribeMasterSlaveServerGroupsOutcome;
 			typedef std::future<DescribeMasterSlaveServerGroupsOutcome> DescribeMasterSlaveServerGroupsOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveServerGroupsRequest&, const DescribeMasterSlaveServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveServerGroupsAsyncHandler;
-			typedef Outcome<Error, Model::DescribeMasterSlaveVServerGroupAttributeResult> DescribeMasterSlaveVServerGroupAttributeOutcome;
-			typedef std::future<DescribeMasterSlaveVServerGroupAttributeOutcome> DescribeMasterSlaveVServerGroupAttributeOutcomeCallable;
-			typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveVServerGroupAttributeRequest&, const DescribeMasterSlaveVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveVServerGroupAttributeAsyncHandler;
-			typedef Outcome<Error, Model::DescribeMasterSlaveVServerGroupsResult> DescribeMasterSlaveVServerGroupsOutcome;
-			typedef std::future<DescribeMasterSlaveVServerGroupsOutcome> DescribeMasterSlaveVServerGroupsOutcomeCallable;
-			typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveVServerGroupsRequest&, const DescribeMasterSlaveVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveVServerGroupsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
@@ -360,6 +349,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
 			typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
+			typedef Outcome<Error, Model::ListTLSCipherPoliciesResult> ListTLSCipherPoliciesOutcome;
+			typedef std::future<ListTLSCipherPoliciesOutcome> ListTLSCipherPoliciesOutcomeCallable;
+			typedef std::function<void(const SlbClient*, const Model::ListTLSCipherPoliciesRequest&, const ListTLSCipherPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTLSCipherPoliciesAsyncHandler;
 			typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
 			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
@@ -414,9 +406,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetLoadBalancerHTTPSListenerAttributeResult> SetLoadBalancerHTTPSListenerAttributeOutcome;
 			typedef std::future<SetLoadBalancerHTTPSListenerAttributeOutcome> SetLoadBalancerHTTPSListenerAttributeOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPSListenerAttributeRequest&, const SetLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPSListenerAttributeAsyncHandler;
-			typedef Outcome<Error, Model::SetLoadBalancerListenerAttributeExResult> SetLoadBalancerListenerAttributeExOutcome;
-			typedef std::future<SetLoadBalancerListenerAttributeExOutcome> SetLoadBalancerListenerAttributeExOutcomeCallable;
-			typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerListenerAttributeExRequest&, const SetLoadBalancerListenerAttributeExOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerListenerAttributeExAsyncHandler;
+			typedef Outcome<Error, Model::SetLoadBalancerModificationProtectionResult> SetLoadBalancerModificationProtectionOutcome;
+			typedef std::future<SetLoadBalancerModificationProtectionOutcome> SetLoadBalancerModificationProtectionOutcomeCallable;
+			typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerModificationProtectionRequest&, const SetLoadBalancerModificationProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerModificationProtectionAsyncHandler;
 			typedef Outcome<Error, Model::SetLoadBalancerNameResult> SetLoadBalancerNameOutcome;
 			typedef std::future<SetLoadBalancerNameOutcome> SetLoadBalancerNameOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerNameRequest&, const SetLoadBalancerNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerNameAsyncHandler;
@@ -435,6 +427,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetServerCertificateNameResult> SetServerCertificateNameOutcome;
 			typedef std::future<SetServerCertificateNameOutcome> SetServerCertificateNameOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::SetServerCertificateNameRequest&, const SetServerCertificateNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetServerCertificateNameAsyncHandler;
+			typedef Outcome<Error, Model::SetTLSCipherPolicyAttributeResult> SetTLSCipherPolicyAttributeOutcome;
+			typedef std::future<SetTLSCipherPolicyAttributeOutcome> SetTLSCipherPolicyAttributeOutcomeCallable;
+			typedef std::function<void(const SlbClient*, const Model::SetTLSCipherPolicyAttributeRequest&, const SetTLSCipherPolicyAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetTLSCipherPolicyAttributeAsyncHandler;
 			typedef Outcome<Error, Model::SetVServerGroupAttributeResult> SetVServerGroupAttributeOutcome;
 			typedef std::future<SetVServerGroupAttributeOutcome> SetVServerGroupAttributeOutcomeCallable;
 			typedef std::function<void(const SlbClient*, const Model::SetVServerGroupAttributeRequest&, const SetVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetVServerGroupAttributeAsyncHandler;
@@ -500,12 +495,12 @@ namespace AlibabaCloud
 			CreateMasterSlaveServerGroupOutcome createMasterSlaveServerGroup(const Model::CreateMasterSlaveServerGroupRequest &request)const;
 			void createMasterSlaveServerGroupAsync(const Model::CreateMasterSlaveServerGroupRequest& request, const CreateMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateMasterSlaveServerGroupOutcomeCallable createMasterSlaveServerGroupCallable(const Model::CreateMasterSlaveServerGroupRequest& request) const;
-			CreateMasterSlaveVServerGroupOutcome createMasterSlaveVServerGroup(const Model::CreateMasterSlaveVServerGroupRequest &request)const;
-			void createMasterSlaveVServerGroupAsync(const Model::CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateMasterSlaveVServerGroupOutcomeCallable createMasterSlaveVServerGroupCallable(const Model::CreateMasterSlaveVServerGroupRequest& request) const;
 			CreateRulesOutcome createRules(const Model::CreateRulesRequest &request)const;
 			void createRulesAsync(const Model::CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRulesOutcomeCallable createRulesCallable(const Model::CreateRulesRequest& request) const;
+			CreateTLSCipherPolicyOutcome createTLSCipherPolicy(const Model::CreateTLSCipherPolicyRequest &request)const;
+			void createTLSCipherPolicyAsync(const Model::CreateTLSCipherPolicyRequest& request, const CreateTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateTLSCipherPolicyOutcomeCallable createTLSCipherPolicyCallable(const Model::CreateTLSCipherPolicyRequest& request) const;
 			CreateVServerGroupOutcome createVServerGroup(const Model::CreateVServerGroupRequest &request)const;
 			void createVServerGroupAsync(const Model::CreateVServerGroupRequest& request, const CreateVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVServerGroupOutcomeCallable createVServerGroupCallable(const Model::CreateVServerGroupRequest& request) const;
@@ -527,15 +522,15 @@ namespace AlibabaCloud
 			DeleteMasterSlaveServerGroupOutcome deleteMasterSlaveServerGroup(const Model::DeleteMasterSlaveServerGroupRequest &request)const;
 			void deleteMasterSlaveServerGroupAsync(const Model::DeleteMasterSlaveServerGroupRequest& request, const DeleteMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteMasterSlaveServerGroupOutcomeCallable deleteMasterSlaveServerGroupCallable(const Model::DeleteMasterSlaveServerGroupRequest& request) const;
-			DeleteMasterSlaveVServerGroupOutcome deleteMasterSlaveVServerGroup(const Model::DeleteMasterSlaveVServerGroupRequest &request)const;
-			void deleteMasterSlaveVServerGroupAsync(const Model::DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteMasterSlaveVServerGroupOutcomeCallable deleteMasterSlaveVServerGroupCallable(const Model::DeleteMasterSlaveVServerGroupRequest& request) const;
 			DeleteRulesOutcome deleteRules(const Model::DeleteRulesRequest &request)const;
 			void deleteRulesAsync(const Model::DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteRulesOutcomeCallable deleteRulesCallable(const Model::DeleteRulesRequest& request) const;
 			DeleteServerCertificateOutcome deleteServerCertificate(const Model::DeleteServerCertificateRequest &request)const;
 			void deleteServerCertificateAsync(const Model::DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteServerCertificateOutcomeCallable deleteServerCertificateCallable(const Model::DeleteServerCertificateRequest& request) const;
+			DeleteTLSCipherPolicyOutcome deleteTLSCipherPolicy(const Model::DeleteTLSCipherPolicyRequest &request)const;
+			void deleteTLSCipherPolicyAsync(const Model::DeleteTLSCipherPolicyRequest& request, const DeleteTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTLSCipherPolicyOutcomeCallable deleteTLSCipherPolicyCallable(const Model::DeleteTLSCipherPolicyRequest& request) const;
 			DeleteVServerGroupOutcome deleteVServerGroup(const Model::DeleteVServerGroupRequest &request)const;
 			void deleteVServerGroupAsync(const Model::DeleteVServerGroupRequest& request, const DeleteVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteVServerGroupOutcomeCallable deleteVServerGroupCallable(const Model::DeleteVServerGroupRequest& request) const;
@@ -572,9 +567,6 @@ namespace AlibabaCloud
 			DescribeLoadBalancerHTTPSListenerAttributeOutcome describeLoadBalancerHTTPSListenerAttribute(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest &request)const;
 			void describeLoadBalancerHTTPSListenerAttributeAsync(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request, const DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable describeLoadBalancerHTTPSListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request) const;
-			DescribeLoadBalancerListenersExOutcome describeLoadBalancerListenersEx(const Model::DescribeLoadBalancerListenersExRequest &request)const;
-			void describeLoadBalancerListenersExAsync(const Model::DescribeLoadBalancerListenersExRequest& request, const DescribeLoadBalancerListenersExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeLoadBalancerListenersExOutcomeCallable describeLoadBalancerListenersExCallable(const Model::DescribeLoadBalancerListenersExRequest& request) const;
 			DescribeLoadBalancerTCPListenerAttributeOutcome describeLoadBalancerTCPListenerAttribute(const Model::DescribeLoadBalancerTCPListenerAttributeRequest &request)const;
 			void describeLoadBalancerTCPListenerAttributeAsync(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request, const DescribeLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeLoadBalancerTCPListenerAttributeOutcomeCallable describeLoadBalancerTCPListenerAttributeCallable(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request) const;
@@ -590,12 +582,6 @@ namespace AlibabaCloud
 			DescribeMasterSlaveServerGroupsOutcome describeMasterSlaveServerGroups(const Model::DescribeMasterSlaveServerGroupsRequest &request)const;
 			void describeMasterSlaveServerGroupsAsync(const Model::DescribeMasterSlaveServerGroupsRequest& request, const DescribeMasterSlaveServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeMasterSlaveServerGroupsOutcomeCallable describeMasterSlaveServerGroupsCallable(const Model::DescribeMasterSlaveServerGroupsRequest& request) const;
-			DescribeMasterSlaveVServerGroupAttributeOutcome describeMasterSlaveVServerGroupAttribute(const Model::DescribeMasterSlaveVServerGroupAttributeRequest &request)const;
-			void describeMasterSlaveVServerGroupAttributeAsync(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeMasterSlaveVServerGroupAttributeOutcomeCallable describeMasterSlaveVServerGroupAttributeCallable(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request) const;
-			DescribeMasterSlaveVServerGroupsOutcome describeMasterSlaveVServerGroups(const Model::DescribeMasterSlaveVServerGroupsRequest &request)const;
-			void describeMasterSlaveVServerGroupsAsync(const Model::DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeMasterSlaveVServerGroupsOutcomeCallable describeMasterSlaveVServerGroupsCallable(const Model::DescribeMasterSlaveVServerGroupsRequest& request) const;
 			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
 			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
@@ -620,6 +606,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;
+			ListTLSCipherPoliciesOutcome listTLSCipherPolicies(const Model::ListTLSCipherPoliciesRequest &request)const;
+			void listTLSCipherPoliciesAsync(const Model::ListTLSCipherPoliciesRequest& request, const ListTLSCipherPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTLSCipherPoliciesOutcomeCallable listTLSCipherPoliciesCallable(const Model::ListTLSCipherPoliciesRequest& request) const;
 			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
 			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
@@ -674,9 +663,9 @@ namespace AlibabaCloud
 			SetLoadBalancerHTTPSListenerAttributeOutcome setLoadBalancerHTTPSListenerAttribute(const Model::SetLoadBalancerHTTPSListenerAttributeRequest &request)const;
 			void setLoadBalancerHTTPSListenerAttributeAsync(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request, const SetLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetLoadBalancerHTTPSListenerAttributeOutcomeCallable setLoadBalancerHTTPSListenerAttributeCallable(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request) const;
-			SetLoadBalancerListenerAttributeExOutcome setLoadBalancerListenerAttributeEx(const Model::SetLoadBalancerListenerAttributeExRequest &request)const;
-			void setLoadBalancerListenerAttributeExAsync(const Model::SetLoadBalancerListenerAttributeExRequest& request, const SetLoadBalancerListenerAttributeExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			SetLoadBalancerListenerAttributeExOutcomeCallable setLoadBalancerListenerAttributeExCallable(const Model::SetLoadBalancerListenerAttributeExRequest& request) const;
+			SetLoadBalancerModificationProtectionOutcome setLoadBalancerModificationProtection(const Model::SetLoadBalancerModificationProtectionRequest &request)const;
+			void setLoadBalancerModificationProtectionAsync(const Model::SetLoadBalancerModificationProtectionRequest& request, const SetLoadBalancerModificationProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetLoadBalancerModificationProtectionOutcomeCallable setLoadBalancerModificationProtectionCallable(const Model::SetLoadBalancerModificationProtectionRequest& request) const;
 			SetLoadBalancerNameOutcome setLoadBalancerName(const Model::SetLoadBalancerNameRequest &request)const;
 			void setLoadBalancerNameAsync(const Model::SetLoadBalancerNameRequest& request, const SetLoadBalancerNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetLoadBalancerNameOutcomeCallable setLoadBalancerNameCallable(const Model::SetLoadBalancerNameRequest& request) const;
@@ -695,6 +684,9 @@ namespace AlibabaCloud
 			SetServerCertificateNameOutcome setServerCertificateName(const Model::SetServerCertificateNameRequest &request)const;
 			void setServerCertificateNameAsync(const Model::SetServerCertificateNameRequest& request, const SetServerCertificateNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetServerCertificateNameOutcomeCallable setServerCertificateNameCallable(const Model::SetServerCertificateNameRequest& request) const;
+			SetTLSCipherPolicyAttributeOutcome setTLSCipherPolicyAttribute(const Model::SetTLSCipherPolicyAttributeRequest &request)const;
+			void setTLSCipherPolicyAttributeAsync(const Model::SetTLSCipherPolicyAttributeRequest& request, const SetTLSCipherPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetTLSCipherPolicyAttributeOutcomeCallable setTLSCipherPolicyAttributeCallable(const Model::SetTLSCipherPolicyAttributeRequest& request) const;
 			SetVServerGroupAttributeOutcome setVServerGroupAttribute(const Model::SetVServerGroupAttributeRequest &request)const;
 			void setVServerGroupAttributeAsync(const Model::SetVServerGroupAttributeRequest& request, const SetVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetVServerGroupAttributeOutcomeCallable setVServerGroupAttributeCallable(const Model::SetVServerGroupAttributeRequest& request) const;

slb/include/alibabacloud/slb/model/CreateDomainExtensionRequest.h

@@ -30,6 +30,13 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_SLB_EXPORT CreateDomainExtensionRequest : public RpcServiceRequest
 			{
+			public:
+				struct ServerCertificate
+				{
+					std::string bindingType;
+					std::string certificateId;
+					std::string standardType;
+				};
 
 			public:
 				CreateDomainExtensionRequest();
@@ -39,6 +46,8 @@ namespace AlibabaCloud
 				void setAccess_key_id(const std::string& access_key_id);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::vector<ServerCertificate> getServerCertificate()const;
+				void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				int getListenerPort()const;
@@ -47,6 +56,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::vector<std::string> getCertificateId()const;
+				void setCertificateId(const std::vector<std::string>& certificateId);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getServerCertificateId()const;
@@ -61,10 +72,12 @@ namespace AlibabaCloud
             private:
 				std::string access_key_id_;
 				long resourceOwnerId_;
+				std::vector<ServerCertificate> serverCertificate_;
 				std::string regionId_;
 				int listenerPort_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::vector<std::string> certificateId_;
 				long ownerId_;
 				std::string serverCertificateId_;
 				std::string tags_;

slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h

@@ -30,6 +30,13 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerRequest : public RpcServiceRequest
 			{
+			public:
+				struct ServerCertificate
+				{
+					std::string bindingType;
+					std::string certificateId;
+					std::string standardType;
+				};
 
 			public:
 				CreateLoadBalancerHTTPSListenerRequest();
@@ -37,6 +44,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::vector<ServerCertificate> getServerCertificate()const;
+				void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
 				int getHealthCheckTimeout()const;
 				void setHealthCheckTimeout(int healthCheckTimeout);
 				std::string getXForwardedFor()const;
@@ -152,6 +161,7 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
+				std::vector<ServerCertificate> serverCertificate_;
 				int healthCheckTimeout_;
 				std::string xForwardedFor_;
 				std::string healthCheckURI_;

slb/include/alibabacloud/slb/model/CreateLoadBalancerRequest.h

@@ -35,36 +35,50 @@ namespace AlibabaCloud
 				CreateLoadBalancerRequest();
 				~CreateLoadBalancerRequest();
 
-				std::string getAccess_key_id()const;
-				void setAccess_key_id(const std::string& access_key_id);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				bool getSupportPrivateLink()const;
-				void setSupportPrivateLink(bool supportPrivateLink);
-				std::string getClientToken()const;
-				void setClientToken(const std::string& clientToken);
-				std::string getCloudType()const;
-				void setCloudType(const std::string& cloudType);
 				std::string getAddressIPVersion()const;
 				void setAddressIPVersion(const std::string& addressIPVersion);
 				std::string getMasterZoneId()const;
 				void setMasterZoneId(const std::string& masterZoneId);
-				int getDuration()const;
-				void setDuration(int duration);
 				std::string getResourceGroupId()const;
 				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getLoadBalancerName()const;
 				void setLoadBalancerName(const std::string& loadBalancerName);
+				std::string getSlaveZoneId()const;
+				void setSlaveZoneId(const std::string& slaveZoneId);
+				std::string getLoadBalancerSpec()const;
+				void setLoadBalancerSpec(const std::string& loadBalancerSpec);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::string getEnableVpcVipFlow()const;
+				void setEnableVpcVipFlow(const std::string& enableVpcVipFlow);
+				std::string getInternetChargeType()const;
+				void setInternetChargeType(const std::string& internetChargeType);
+				std::string getPricingCycle()const;
+				void setPricingCycle(const std::string& pricingCycle);
+				std::string getAccess_key_id()const;
+				void setAccess_key_id(const std::string& access_key_id);
+				std::string getModificationProtectionReason()const;
+				void setModificationProtectionReason(const std::string& modificationProtectionReason);
+				bool getSupportPrivateLink()const;
+				void setSupportPrivateLink(bool supportPrivateLink);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getCloudType()const;
+				void setCloudType(const std::string& cloudType);
+				int getDuration()const;
+				void setDuration(int duration);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getAddressType()const;
 				void setAddressType(const std::string& addressType);
-				std::string getSlaveZoneId()const;
-				void setSlaveZoneId(const std::string& slaveZoneId);
 				std::string getDeleteProtection()const;
 				void setDeleteProtection(const std::string& deleteProtection);
-				std::string getLoadBalancerSpec()const;
-				void setLoadBalancerSpec(const std::string& loadBalancerSpec);
 				bool getAutoPay()const;
 				void setAutoPay(bool autoPay);
 				std::string getAddress()const;
@@ -75,54 +89,46 @@ namespace AlibabaCloud
 				void setBandwidth(int bandwidth);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
-				long getOwnerId()const;
-				void setOwnerId(long ownerId);
-				std::string getTags()const;
-				void setTags(const std::string& tags);
-				std::string getVSwitchId()const;
-				void setVSwitchId(const std::string& vSwitchId);
-				std::string getEnableVpcVipFlow()const;
-				void setEnableVpcVipFlow(const std::string& enableVpcVipFlow);
-				std::string getInternetChargeType()const;
-				void setInternetChargeType(const std::string& internetChargeType);
+				std::string getModificationProtectionStatus()const;
+				void setModificationProtectionStatus(const std::string& modificationProtectionStatus);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 				std::string getPayType()const;
 				void setPayType(const std::string& payType);
-				std::string getPricingCycle()const;
-				void setPricingCycle(const std::string& pricingCycle);
 				int getRatio()const;
 				void setRatio(int ratio);
 
             private:
-				std::string access_key_id_;
 				long resourceOwnerId_;
-				bool supportPrivateLink_;
-				std::string clientToken_;
-				std::string cloudType_;
 				std::string addressIPVersion_;
 				std::string masterZoneId_;
-				int duration_;
 				std::string resourceGroupId_;
 				std::string loadBalancerName_;
+				std::string slaveZoneId_;
+				std::string loadBalancerSpec_;
+				long ownerId_;
+				std::string tags_;
+				std::string vSwitchId_;
+				std::string enableVpcVipFlow_;
+				std::string internetChargeType_;
+				std::string pricingCycle_;
+				std::string access_key_id_;
+				std::string modificationProtectionReason_;
+				bool supportPrivateLink_;
+				std::string clientToken_;
+				std::string cloudType_;
+				int duration_;
 				std::string regionId_;
 				std::string addressType_;
-				std::string slaveZoneId_;
 				std::string deleteProtection_;
-				std::string loadBalancerSpec_;
 				bool autoPay_;
 				std::string address_;
 				std::string resourceOwnerAccount_;
 				int bandwidth_;
 				std::string ownerAccount_;
-				long ownerId_;
-				std::string tags_;
-				std::string vSwitchId_;
-				std::string enableVpcVipFlow_;
-				std::string internetChargeType_;
+				std::string modificationProtectionStatus_;
 				std::string vpcId_;
 				std::string payType_;
-				std::string pricingCycle_;
 				int ratio_;
 
 			};

slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h

@@ -1,65 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_
-#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/slb/SlbExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Slb
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupResult : public ServiceResult
-			{
-			public:
-				struct MasterSlaveBackendServer
-				{
-					std::string type;
-					std::string serverId;
-					std::string description;
-					std::string vpcId;
-					std::string eniHost;
-					int port;
-					std::string serverIp;
-					int isBackup;
-					int weight;
-				};
-
-
-				CreateMasterSlaveVServerGroupResult();
-				explicit CreateMasterSlaveVServerGroupResult(const std::string &payload);
-				~CreateMasterSlaveVServerGroupResult();
-				std::string getMasterSlaveVServerGroupId()const;
-				std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				std::string masterSlaveVServerGroupId_;
-				std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_

slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h → slb/include/alibabacloud/slb/model/CreateTLSCipherPolicyRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
-#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_
+#define ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SLB_EXPORT CreateTLSCipherPolicyRequest : public RpcServiceRequest
 			{
 
 			public:
-				DeleteMasterSlaveVServerGroupRequest();
-				~DeleteMasterSlaveVServerGroupRequest();
+				CreateTLSCipherPolicyRequest();
+				~CreateTLSCipherPolicyRequest();
 
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
@@ -43,30 +43,33 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
-				std::string getMasterSlaveVServerGroupId()const;
-				void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
+				std::vector<std::string> getCiphers()const;
+				void setCiphers(const std::vector<std::string>& ciphers);
+				std::vector<std::string> getTLSVersions()const;
+				void setTLSVersions(const std::vector<std::string>& tLSVersions);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getTags()const;
-				void setTags(const std::string& tags);
+				std::string getName()const;
+				void setName(const std::string& name);
 
             private:
 				std::string access_key_id_;
 				long resourceOwnerId_;
 				std::string accessKeyId_;
 				std::string regionId_;
-				std::string masterSlaveVServerGroupId_;
+				std::vector<std::string> ciphers_;
+				std::vector<std::string> tLSVersions_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
-				std::string tags_;
+				std::string name_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_

slb/include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h → slb/include/alibabacloud/slb/model/CreateTLSCipherPolicyResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXRESULT_H_
-#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXRESULT_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_
+#define ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,21 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerListenerAttributeExResult : public ServiceResult
+			class ALIBABACLOUD_SLB_EXPORT CreateTLSCipherPolicyResult : public ServiceResult
 			{
 			public:
 
 
-				SetLoadBalancerListenerAttributeExResult();
-				explicit SetLoadBalancerListenerAttributeExResult(const std::string &payload);
-				~SetLoadBalancerListenerAttributeExResult();
+				CreateTLSCipherPolicyResult();
+				explicit CreateTLSCipherPolicyResult(const std::string &payload);
+				~CreateTLSCipherPolicyResult();
+				std::string getTLSCipherPolicyId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string tLSCipherPolicyId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXRESULT_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_

slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h → slb/include/alibabacloud/slb/model/DeleteTLSCipherPolicyRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
-#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_
+#define ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SLB_EXPORT DeleteTLSCipherPolicyRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeMasterSlaveVServerGroupsRequest();
-				~DescribeMasterSlaveVServerGroupsRequest();
+				DeleteTLSCipherPolicyRequest();
+				~DeleteTLSCipherPolicyRequest();
 
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getTLSCipherPolicyId()const;
+				void setTLSCipherPolicyId(const std::string& tLSCipherPolicyId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getResourceOwnerAccount()const;
@@ -49,24 +51,19 @@ namespace AlibabaCloud
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getTags()const;
-				void setTags(const std::string& tags);
-				std::string getLoadBalancerId()const;
-				void setLoadBalancerId(const std::string& loadBalancerId);
 
             private:
 				std::string access_key_id_;
 				long resourceOwnerId_;
 				std::string accessKeyId_;
+				std::string tLSCipherPolicyId_;
 				std::string regionId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
-				std::string tags_;
-				std::string loadBalancerId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_

slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h → slb/include/alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
-#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_
+#define ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupResult : public ServiceResult
+			class ALIBABACLOUD_SLB_EXPORT DeleteTLSCipherPolicyResult : public ServiceResult
 			{
 			public:
 
 
-				DeleteMasterSlaveVServerGroupResult();
-				explicit DeleteMasterSlaveVServerGroupResult(const std::string &payload);
-				~DeleteMasterSlaveVServerGroupResult();
+				DeleteTLSCipherPolicyResult();
+				explicit DeleteTLSCipherPolicyResult(const std::string &payload);
+				~DeleteTLSCipherPolicyResult();
 
 			protected:
 				void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_

slb/include/alibabacloud/slb/model/DescribeCACertificatesResult.h

@@ -44,7 +44,10 @@ namespace AlibabaCloud
 					long expireTimeStamp;
 					std::string cACertificateId;
 					std::string createTime;
+					std::string standardType;
 					std::string cACertificateName;
+					int encryptionKeyLength;
+					std::string encryptionAlgorithm;
 					std::string regionId;
 					std::string expireTime;
 					std::vector<CACertificate::Tag> tags;

slb/include/alibabacloud/slb/model/DescribeDomainExtensionAttributeResult.h

@@ -32,6 +32,18 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_SLB_EXPORT DescribeDomainExtensionAttributeResult : public ServiceResult
 			{
 			public:
+				struct Certificate
+				{
+					std::string certificateId;
+					std::string encryptionAlgorithm;
+				};
+				struct ServerCertificate
+				{
+					std::string certificateId;
+					std::string bindingType;
+					std::string encryptionAlgorithm;
+					std::string standardType;
+				};
 
 
 				DescribeDomainExtensionAttributeResult();
@@ -39,6 +51,8 @@ namespace AlibabaCloud
 				~DescribeDomainExtensionAttributeResult();
 				std::string getDomainExtensionId()const;
 				int getListenerPort()const;
+				std::vector<Certificate> getCertificates()const;
+				std::vector<ServerCertificate> getServerCertificates()const;
 				std::string getServerCertificateId()const;
 				std::string getLoadBalancerId()const;
 				std::string getDomain()const;
@@ -48,6 +62,8 @@ namespace AlibabaCloud
 			private:
 				std::string domainExtensionId_;
 				int listenerPort_;
+				std::vector<Certificate> certificates_;
+				std::vector<ServerCertificate> serverCertificates_;
 				std::string serverCertificateId_;
 				std::string loadBalancerId_;
 				std::string domain_;

slb/include/alibabacloud/slb/model/DescribeDomainExtensionsResult.h

@@ -34,7 +34,21 @@ namespace AlibabaCloud
 			public:
 				struct DomainExtension
 				{
+					struct Certificate
+					{
+						std::string certificateId;
+						std::string encryptionAlgorithm;
+					};
+					struct ServerCertificate
+					{
+						std::string certificateId;
+						std::string bindingType;
+						std::string encryptionAlgorithm;
+						std::string standardType;
+					};
 					std::string domainExtensionId;
+					std::vector<DomainExtension::Certificate> certificates;
+					std::vector<DomainExtension::ServerCertificate> serverCertificates;
 					std::string serverCertificateId;
 					std::string domain;
 				};

slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h

@@ -71,10 +71,13 @@ namespace AlibabaCloud
 				std::string getLoadBalancerId()const;
 				std::vector<BackendServer> getBackendServers()const;
 				std::string getHasReservedInfo()const;
+				std::string getBusinessStatus()const;
 				std::string getReservedInfoBandwidth()const;
+				std::string getModificationProtectionStatus()const;
 				std::string getLoadBalancerSpec()const;
 				std::string getNetworkType()const;
 				int getBandwidth()const;
+				std::string getModificationProtectionReason()const;
 				std::string getAssociatedCenId()const;
 				std::vector<std::string> getListenerPorts()const;
 				std::string getMasterZoneId()const;
@@ -120,10 +123,13 @@ namespace AlibabaCloud
 				std::string loadBalancerId_;
 				std::vector<BackendServer> backendServers_;
 				std::string hasReservedInfo_;
+				std::string businessStatus_;
 				std::string reservedInfoBandwidth_;
+				std::string modificationProtectionStatus_;
 				std::string loadBalancerSpec_;
 				std::string networkType_;
 				int bandwidth_;
+				std::string modificationProtectionReason_;
 				std::string associatedCenId_;
 				std::vector<std::string> listenerPorts_;
 				std::string masterZoneId_;

slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h

@@ -42,10 +42,31 @@ namespace AlibabaCloud
 				};
 				struct DomainExtension
 				{
+					struct Certificate
+					{
+						std::string certificateId;
+						std::string encryptionAlgorithm;
+					};
+					struct ServerCertificate
+					{
+						std::string certificateId;
+						std::string bindingType;
+						std::string encryptionAlgorithm;
+						std::string standardType;
+					};
 					std::string domainExtensionId;
+					std::vector<DomainExtension::ServerCertificate> serverCertificates1;
+					std::vector<DomainExtension::Certificate> certificates;
 					std::string serverCertificateId;
 					std::string domain;
 				};
+				struct ServerCertificate2
+				{
+					std::string certificateId;
+					std::string bindingType;
+					std::string encryptionAlgorithm;
+					std::string standardType;
+				};
 
 
 				DescribeLoadBalancerHTTPSListenerAttributeResult();
@@ -66,6 +87,7 @@ namespace AlibabaCloud
 				int getHealthCheckInterval()const;
 				std::string getTLSCipherPolicy()const;
 				std::string getCACertificateId()const;
+				std::vector<ServerCertificate2> getServerCertificates()const;
 				std::string getXForwardedFor_ClientCertFingerprintAlias()const;
 				int getHealthCheckTimeout()const;
 				std::string getAclStatus()const;
@@ -124,6 +146,7 @@ namespace AlibabaCloud
 				int healthCheckInterval_;
 				std::string tLSCipherPolicy_;
 				std::string cACertificateId_;
+				std::vector<ServerCertificate2> serverCertificates_;
 				std::string xForwardedFor_ClientCertFingerprintAlias_;
 				int healthCheckTimeout_;
 				std::string aclStatus_;

slb/include/alibabacloud/slb/model/DescribeLoadBalancerListenersExRequest.h

@@ -1,57 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXREQUEST_H_
-#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/slb/SlbExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Slb
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerListenersExRequest : public RpcServiceRequest
-			{
-
-			public:
-				DescribeLoadBalancerListenersExRequest();
-				~DescribeLoadBalancerListenersExRequest();
-
-				int getListenerPort()const;
-				void setListenerPort(int listenerPort);
-				std::string getProtocol()const;
-				void setProtocol(const std::string& protocol);
-				std::string getLoadBalancerId()const;
-				void setLoadBalancerId(const std::string& loadBalancerId);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
-
-            private:
-				int listenerPort_;
-				std::string protocol_;
-				std::string loadBalancerId_;
-				std::string regionId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXREQUEST_H_

slb/include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h

@@ -41,48 +41,26 @@ namespace AlibabaCloud
 				DescribeLoadBalancersRequest();
 				~DescribeLoadBalancersRequest();
 
-				std::string getAccess_key_id()const;
-				void setAccess_key_id(const std::string& access_key_id);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				bool getSupportPrivateLink()const;
-				void setSupportPrivateLink(bool supportPrivateLink);
 				std::string getNetworkType()const;
 				void setNetworkType(const std::string& networkType);
 				std::string getAddressIPVersion()const;
 				void setAddressIPVersion(const std::string& addressIPVersion);
 				std::string getMasterZoneId()const;
 				void setMasterZoneId(const std::string& masterZoneId);
-				int getPageNumber()const;
-				void setPageNumber(int pageNumber);
 				std::string getResourceGroupId()const;
 				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getLoadBalancerName()const;
 				void setLoadBalancerName(const std::string& loadBalancerName);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
-				int getPageSize()const;
-				void setPageSize(int pageSize);
-				std::string getAddressType()const;
-				void setAddressType(const std::string& addressType);
 				std::string getSlaveZoneId()const;
 				void setSlaveZoneId(const std::string& slaveZoneId);
 				std::vector<Tag> getTag()const;
 				void setTag(const std::vector<Tag>& tag);
-				std::string getFuzzy()const;
-				void setFuzzy(const std::string& fuzzy);
-				std::string getAddress()const;
-				void setAddress(const std::string& address);
-				std::string getResourceOwnerAccount()const;
-				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
-				std::string getOwnerAccount()const;
-				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getServerId()const;
 				void setServerId(const std::string& serverId);
-				std::string getLoadBalancerStatus()const;
-				void setLoadBalancerStatus(const std::string& loadBalancerStatus);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 				std::string getServerIntranetAddress()const;
@@ -93,38 +71,63 @@ namespace AlibabaCloud
 				void setLoadBalancerId(const std::string& loadBalancerId);
 				std::string getInternetChargeType()const;
 				void setInternetChargeType(const std::string& internetChargeType);
+				std::string getAccess_key_id()const;
+				void setAccess_key_id(const std::string& access_key_id);
+				bool getSupportPrivateLink()const;
+				void setSupportPrivateLink(bool supportPrivateLink);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getAddressType()const;
+				void setAddressType(const std::string& addressType);
+				std::string getFuzzy()const;
+				void setFuzzy(const std::string& fuzzy);
+				std::string getBusinessStatus()const;
+				void setBusinessStatus(const std::string& businessStatus);
+				std::string getAddress()const;
+				void setAddress(const std::string& address);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getLoadBalancerStatus()const;
+				void setLoadBalancerStatus(const std::string& loadBalancerStatus);
 				std::string getVpcId()const;
 				void setVpcId(const std::string& vpcId);
 				std::string getPayType()const;
 				void setPayType(const std::string& payType);
 
             private:
-				std::string access_key_id_;
 				long resourceOwnerId_;
-				bool supportPrivateLink_;
 				std::string networkType_;
 				std::string addressIPVersion_;
 				std::string masterZoneId_;
-				int pageNumber_;
 				std::string resourceGroupId_;
 				std::string loadBalancerName_;
-				std::string regionId_;
-				int pageSize_;
-				std::string addressType_;
 				std::string slaveZoneId_;
 				std::vector<Tag> tag_;
-				std::string fuzzy_;
-				std::string address_;
-				std::string resourceOwnerAccount_;
-				std::string ownerAccount_;
 				long ownerId_;
 				std::string serverId_;
-				std::string loadBalancerStatus_;
 				std::string tags_;
 				std::string serverIntranetAddress_;
 				std::string vSwitchId_;
 				std::string loadBalancerId_;
 				std::string internetChargeType_;
+				std::string access_key_id_;
+				bool supportPrivateLink_;
+				int pageNumber_;
+				std::string regionId_;
+				int pageSize_;
+				std::string addressType_;
+				std::string fuzzy_;
+				std::string businessStatus_;
+				std::string address_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string loadBalancerStatus_;
 				std::string vpcId_;
 				std::string payType_;
 

slb/include/alibabacloud/slb/model/DescribeLoadBalancersResult.h

@@ -47,11 +47,14 @@ namespace AlibabaCloud
 					std::string loadBalancerId;
 					std::string payType;
 					std::string slaveZoneId;
+					std::string businessStatus;
+					std::string modificationProtectionStatus;
 					std::string internetChargeType;
 					std::string regionIdAlias;
 					std::string loadBalancerName;
 					std::string vpcId;
 					std::string networkType;
+					std::string modificationProtectionReason;
 					std::string regionId;
 					std::string addressType;
 					std::string loadBalancerStatus;

slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h

@@ -1,67 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_
-#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_
-
-#include <string>
-#include <vector>
-#include <utility>
-#include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/slb/SlbExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Slb
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeResult : public ServiceResult
-			{
-			public:
-				struct MasterSlaveBackendServer
-				{
-					std::string type;
-					std::string serverId;
-					std::string description;
-					std::string vpcId;
-					std::string eniHost;
-					int port;
-					std::string serverIp;
-					int isBackup;
-					int weight;
-				};
-
-
-				DescribeMasterSlaveVServerGroupAttributeResult();
-				explicit DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload);
-				~DescribeMasterSlaveVServerGroupAttributeResult();
-				std::string getMasterSlaveVServerGroupId()const;
-				std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
-				std::string getMasterSlaveVServerGroupName()const;
-
-			protected:
-				void parse(const std::string &payload);
-			private:
-				std::string masterSlaveVServerGroupId_;
-				std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
-				std::string masterSlaveVServerGroupName_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_

slb/include/alibabacloud/slb/model/DescribeServerCertificatesResult.h

@@ -45,11 +45,14 @@ namespace AlibabaCloud
 					std::string createTime;
 					std::vector<std::string> subjectAlternativeNames;
 					std::string aliCloudCertificateId;
+					std::string standardType;
 					std::string regionIdAlias;
 					std::string aliCloudCertificateName;
 					int isAliCloudCertificate;
+					int encryptionKeyLength;
 					std::string serverCertificateId;
 					std::string serverCertificateName;
+					std::string encryptionAlgorithm;
 					std::string regionId;
 					std::string expireTime;
 					std::vector<ServerCertificate::Tag> tags;

slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h → slb/include/alibabacloud/slb/model/ListTLSCipherPoliciesRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
-#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESREQUEST_H_
+#define ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,45 +28,54 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SLB_EXPORT ListTLSCipherPoliciesRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeMasterSlaveVServerGroupAttributeRequest();
-				~DescribeMasterSlaveVServerGroupAttributeRequest();
+				ListTLSCipherPoliciesRequest();
+				~ListTLSCipherPoliciesRequest();
 
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				bool getIncludeListener()const;
+				void setIncludeListener(bool includeListener);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getTLSCipherPolicyId()const;
+				void setTLSCipherPolicyId(const std::string& tLSCipherPolicyId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
-				std::string getMasterSlaveVServerGroupId()const;
-				void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getTags()const;
-				void setTags(const std::string& tags);
+				std::string getName()const;
+				void setName(const std::string& name);
+				int getMaxItems()const;
+				void setMaxItems(int maxItems);
 
             private:
 				std::string access_key_id_;
 				long resourceOwnerId_;
+				bool includeListener_;
 				std::string accessKeyId_;
+				std::string tLSCipherPolicyId_;
 				std::string regionId_;
-				std::string masterSlaveVServerGroupId_;
+				std::string nextToken_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
 				long ownerId_;
-				std::string tags_;
+				std::string name_;
+				int maxItems_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESREQUEST_H_

slb/include/alibabacloud/slb/model/ListTLSCipherPoliciesResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESRESULT_H_
+#define ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/slb/SlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Slb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SLB_EXPORT ListTLSCipherPoliciesResult : public ServiceResult
+			{
+			public:
+				struct TLSCipherPolicy
+				{
+					struct RelateListener
+					{
+						int port;
+						std::string loadBalancerId;
+						std::string protocol;
+					};
+					std::string status;
+					std::vector<TLSCipherPolicy::RelateListener> relateListeners;
+					std::vector<std::string> ciphers;
+					std::string instanceId;
+					long createTime;
+					std::vector<std::string> tLSVersions;
+					std::string name;
+				};
+
+
+				ListTLSCipherPoliciesResult();
+				explicit ListTLSCipherPoliciesResult(const std::string &payload);
+				~ListTLSCipherPoliciesResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				std::vector<TLSCipherPolicy> getTLSCipherPolicies()const;
+				bool getIsTruncated()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				std::vector<TLSCipherPolicy> tLSCipherPolicies_;
+				bool isTruncated_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SLB_MODEL_LISTTLSCIPHERPOLICIESRESULT_H_

slb/include/alibabacloud/slb/model/SetDomainExtensionAttributeRequest.h

@@ -30,6 +30,13 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_SLB_EXPORT SetDomainExtensionAttributeRequest : public RpcServiceRequest
 			{
+			public:
+				struct ServerCertificate
+				{
+					std::string bindingType;
+					std::string certificateId;
+					std::string standardType;
+				};
 
 			public:
 				SetDomainExtensionAttributeRequest();
@@ -39,6 +46,8 @@ namespace AlibabaCloud
 				void setAccess_key_id(const std::string& access_key_id);
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::vector<ServerCertificate> getServerCertificate()const;
+				void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getDomainExtensionId()const;
@@ -47,6 +56,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::vector<std::string> getCertificateId()const;
+				void setCertificateId(const std::vector<std::string>& certificateId);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getServerCertificateId()const;
@@ -57,10 +68,12 @@ namespace AlibabaCloud
             private:
 				std::string access_key_id_;
 				long resourceOwnerId_;
+				std::vector<ServerCertificate> serverCertificate_;
 				std::string regionId_;
 				std::string domainExtensionId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::vector<std::string> certificateId_;
 				long ownerId_;
 				std::string serverCertificateId_;
 				std::string tags_;

slb/include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h

@@ -30,6 +30,13 @@ namespace AlibabaCloud
 		{
 			class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerHTTPSListenerAttributeRequest : public RpcServiceRequest
 			{
+			public:
+				struct ServerCertificate
+				{
+					std::string bindingType;
+					std::string certificateId;
+					std::string standardType;
+				};
 
 			public:
 				SetLoadBalancerHTTPSListenerAttributeRequest();
@@ -37,6 +44,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::vector<ServerCertificate> getServerCertificate()const;
+				void setServerCertificate(const std::vector<ServerCertificate>& serverCertificate);
 				int getHealthCheckTimeout()const;
 				void setHealthCheckTimeout(int healthCheckTimeout);
 				std::string getXForwardedFor()const;
@@ -150,6 +159,7 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
+				std::vector<ServerCertificate> serverCertificate_;
 				int healthCheckTimeout_;
 				std::string xForwardedFor_;
 				std::string healthCheckURI_;

slb/include/alibabacloud/slb/model/SetLoadBalancerListenerAttributeExRequest.h

@@ -1,66 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXREQUEST_H_
-#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXREQUEST_H_
-
-#include <string>
-#include <vector>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/slb/SlbExport.h>
-
-namespace AlibabaCloud
-{
-	namespace Slb
-	{
-		namespace Model
-		{
-			class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerListenerAttributeExRequest : public RpcServiceRequest
-			{
-			public:
-				struct KvAttribute
-				{
-					std::string value;
-					std::string key;
-				};
-
-			public:
-				SetLoadBalancerListenerAttributeExRequest();
-				~SetLoadBalancerListenerAttributeExRequest();
-
-				int getListenerPort()const;
-				void setListenerPort(int listenerPort);
-				std::vector<KvAttribute> getKvAttribute()const;
-				void setKvAttribute(const std::vector<KvAttribute>& kvAttribute);
-				std::string getProtocol()const;
-				void setProtocol(const std::string& protocol);
-				std::string getLoadBalancerId()const;
-				void setLoadBalancerId(const std::string& loadBalancerId);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
-
-            private:
-				int listenerPort_;
-				std::vector<KvAttribute> kvAttribute_;
-				std::string protocol_;
-				std::string loadBalancerId_;
-				std::string regionId_;
-
-			};
-		}
-	}
-}
-#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERATTRIBUTEEXREQUEST_H_

slb/include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONREQUEST_H_
+#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/slb/SlbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Slb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerModificationProtectionRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetLoadBalancerModificationProtectionRequest();
+				~SetLoadBalancerModificationProtectionRequest();
+
+				std::string getModificationProtectionReason()const;
+				void setModificationProtectionReason(const std::string& modificationProtectionReason);
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getModificationProtectionStatus()const;
+				void setModificationProtectionStatus(const std::string& modificationProtectionStatus);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getLoadBalancerId()const;
+				void setLoadBalancerId(const std::string& loadBalancerId);
+
+            private:
+				std::string modificationProtectionReason_;
+				long resourceOwnerId_;
+				std::string regionId_;
+				std::string resourceOwnerAccount_;
+				std::string modificationProtectionStatus_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string loadBalancerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONREQUEST_H_

slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h → slb/include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
-#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONRESULT_H_
+#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,28 +29,21 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsResult : public ServiceResult
+			class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerModificationProtectionResult : public ServiceResult
 			{
 			public:
-				struct MasterSlaveVServerGroup
-				{
-					std::string masterSlaveVServerGroupId;
-					std::string masterSlaveVServerGroupName;
-				};
 
 
-				DescribeMasterSlaveVServerGroupsResult();
-				explicit DescribeMasterSlaveVServerGroupsResult(const std::string &payload);
-				~DescribeMasterSlaveVServerGroupsResult();
-				std::vector<MasterSlaveVServerGroup> getMasterSlaveVServerGroups()const;
+				SetLoadBalancerModificationProtectionResult();
+				explicit SetLoadBalancerModificationProtectionResult(const std::string &payload);
+				~SetLoadBalancerModificationProtectionResult();
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<MasterSlaveVServerGroup> masterSlaveVServerGroups_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERMODIFICATIONPROTECTIONRESULT_H_

slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h → slb/include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
-#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTEREQUEST_H_
 
 #include <string>
 #include <vector>
@@ -28,12 +28,12 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupRequest : public RpcServiceRequest
+			class ALIBABACLOUD_SLB_EXPORT SetTLSCipherPolicyAttributeRequest : public RpcServiceRequest
 			{
 
 			public:
-				CreateMasterSlaveVServerGroupRequest();
-				~CreateMasterSlaveVServerGroupRequest();
+				SetTLSCipherPolicyAttributeRequest();
+				~SetTLSCipherPolicyAttributeRequest();
 
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
@@ -41,38 +41,38 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getMasterSlaveBackendServers()const;
-				void setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers);
+				std::string getTLSCipherPolicyId()const;
+				void setTLSCipherPolicyId(const std::string& tLSCipherPolicyId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::vector<std::string> getCiphers()const;
+				void setCiphers(const std::vector<std::string>& ciphers);
+				std::vector<std::string> getTLSVersions()const;
+				void setTLSVersions(const std::vector<std::string>& tLSVersions);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
-				std::string getMasterSlaveVServerGroupName()const;
-				void setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				std::string getTags()const;
-				void setTags(const std::string& tags);
-				std::string getLoadBalancerId()const;
-				void setLoadBalancerId(const std::string& loadBalancerId);
+				std::string getName()const;
+				void setName(const std::string& name);
 
             private:
 				std::string access_key_id_;
 				long resourceOwnerId_;
 				std::string accessKeyId_;
-				std::string masterSlaveBackendServers_;
+				std::string tLSCipherPolicyId_;
 				std::string regionId_;
+				std::vector<std::string> ciphers_;
+				std::vector<std::string> tLSVersions_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
-				std::string masterSlaveVServerGroupName_;
 				long ownerId_;
-				std::string tags_;
-				std::string loadBalancerId_;
+				std::string name_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTEREQUEST_H_

slb/include/alibabacloud/slb/model/DescribeLoadBalancerListenersExResult.h → slb/include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXRESULT_H_
-#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXRESULT_H_
+#ifndef ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTERESULT_H_
+#define ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,31 +29,23 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerListenersExResult : public ServiceResult
+			class ALIBABACLOUD_SLB_EXPORT SetTLSCipherPolicyAttributeResult : public ServiceResult
 			{
 			public:
-				struct ListenerAttributeExResponseModel
-				{
-					int listenerPort;
-					std::string protocol;
-					std::string recordCustomizedHeaders;
-				};
 
 
-				DescribeLoadBalancerListenersExResult();
-				explicit DescribeLoadBalancerListenersExResult(const std::string &payload);
-				~DescribeLoadBalancerListenersExResult();
-				std::string getLoadBalancerId()const;
-				std::vector<ListenerAttributeExResponseModel> getListenerExtendedAttributes()const;
+				SetTLSCipherPolicyAttributeResult();
+				explicit SetTLSCipherPolicyAttributeResult(const std::string &payload);
+				~SetTLSCipherPolicyAttributeResult();
+				std::string getTaskId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string loadBalancerId_;
-				std::vector<ListenerAttributeExResponseModel> listenerExtendedAttributes_;
+				std::string taskId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSEXRESULT_H_
+#endif // !ALIBABACLOUD_SLB_MODEL_SETTLSCIPHERPOLICYATTRIBUTERESULT_H_

slb/include/alibabacloud/slb/model/UploadCACertificateRequest.h

@@ -51,6 +51,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getStandardType()const;
+				void setStandardType(const std::string& standardType);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 
@@ -63,6 +65,7 @@ namespace AlibabaCloud
 				std::string cACertificate_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::string standardType_;
 				long ownerId_;
 
 			};

slb/include/alibabacloud/slb/model/UploadServerCertificateRequest.h

@@ -55,6 +55,8 @@ namespace AlibabaCloud
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getStandardType()const;
+				void setStandardType(const std::string& standardType);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getTags()const;
@@ -75,6 +77,7 @@ namespace AlibabaCloud
 				std::string regionId_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::string standardType_;
 				long ownerId_;
 				std::string tags_;
 				std::string aliCloudCertificateRegionId_;

slb/src/SlbClient.cc

@@ -519,72 +519,72 @@ SlbClient::CreateMasterSlaveServerGroupOutcomeCallable SlbClient::createMasterSl
 	return task->get_future();
 }
 
-SlbClient::CreateMasterSlaveVServerGroupOutcome SlbClient::createMasterSlaveVServerGroup(const CreateMasterSlaveVServerGroupRequest &request) const
+SlbClient::CreateRulesOutcome SlbClient::createRules(const CreateRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateMasterSlaveVServerGroupOutcome(endpointOutcome.error());
+		return CreateRulesOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateMasterSlaveVServerGroupOutcome(CreateMasterSlaveVServerGroupResult(outcome.result()));
+		return CreateRulesOutcome(CreateRulesResult(outcome.result()));
 	else
-		return CreateMasterSlaveVServerGroupOutcome(outcome.error());
+		return CreateRulesOutcome(outcome.error());
 }
 
-void SlbClient::createMasterSlaveVServerGroupAsync(const CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SlbClient::createRulesAsync(const CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createMasterSlaveVServerGroup(request), context);
+		handler(this, request, createRules(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SlbClient::CreateMasterSlaveVServerGroupOutcomeCallable SlbClient::createMasterSlaveVServerGroupCallable(const CreateMasterSlaveVServerGroupRequest &request) const
+SlbClient::CreateRulesOutcomeCallable SlbClient::createRulesCallable(const CreateRulesRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateMasterSlaveVServerGroupOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateRulesOutcome()>>(
 			[this, request]()
 			{
-			return this->createMasterSlaveVServerGroup(request);
+			return this->createRules(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-SlbClient::CreateRulesOutcome SlbClient::createRules(const CreateRulesRequest &request) const
+SlbClient::CreateTLSCipherPolicyOutcome SlbClient::createTLSCipherPolicy(const CreateTLSCipherPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateRulesOutcome(endpointOutcome.error());
+		return CreateTLSCipherPolicyOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateRulesOutcome(CreateRulesResult(outcome.result()));
+		return CreateTLSCipherPolicyOutcome(CreateTLSCipherPolicyResult(outcome.result()));
 	else
-		return CreateRulesOutcome(outcome.error());
+		return CreateTLSCipherPolicyOutcome(outcome.error());
 }
 
-void SlbClient::createRulesAsync(const CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SlbClient::createTLSCipherPolicyAsync(const CreateTLSCipherPolicyRequest& request, const CreateTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createRules(request), context);
+		handler(this, request, createTLSCipherPolicy(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SlbClient::CreateRulesOutcomeCallable SlbClient::createRulesCallable(const CreateRulesRequest &request) const
+SlbClient::CreateTLSCipherPolicyOutcomeCallable SlbClient::createTLSCipherPolicyCallable(const CreateTLSCipherPolicyRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateRulesOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<CreateTLSCipherPolicyOutcome()>>(
 			[this, request]()
 			{
-			return this->createRules(request);
+			return this->createTLSCipherPolicy(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -843,108 +843,108 @@ SlbClient::DeleteMasterSlaveServerGroupOutcomeCallable SlbClient::deleteMasterSl
 	return task->get_future();
 }
 
-SlbClient::DeleteMasterSlaveVServerGroupOutcome SlbClient::deleteMasterSlaveVServerGroup(const DeleteMasterSlaveVServerGroupRequest &request) const
+SlbClient::DeleteRulesOutcome SlbClient::deleteRules(const DeleteRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DeleteMasterSlaveVServerGroupOutcome(endpointOutcome.error());
+		return DeleteRulesOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DeleteMasterSlaveVServerGroupOutcome(DeleteMasterSlaveVServerGroupResult(outcome.result()));
+		return DeleteRulesOutcome(DeleteRulesResult(outcome.result()));
 	else
-		return DeleteMasterSlaveVServerGroupOutcome(outcome.error());
+		return DeleteRulesOutcome(outcome.error());
 }
 
-void SlbClient::deleteMasterSlaveVServerGroupAsync(const DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SlbClient::deleteRulesAsync(const DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, deleteMasterSlaveVServerGroup(request), context);
+		handler(this, request, deleteRules(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SlbClient::DeleteMasterSlaveVServerGroupOutcomeCallable SlbClient::deleteMasterSlaveVServerGroupCallable(const DeleteMasterSlaveVServerGroupRequest &request) const
+SlbClient::DeleteRulesOutcomeCallable SlbClient::deleteRulesCallable(const DeleteRulesRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DeleteMasterSlaveVServerGroupOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DeleteRulesOutcome()>>(
 			[this, request]()
 			{
-			return this->deleteMasterSlaveVServerGroup(request);
+			return this->deleteRules(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-SlbClient::DeleteRulesOutcome SlbClient::deleteRules(const DeleteRulesRequest &request) const
+SlbClient::DeleteServerCertificateOutcome SlbClient::deleteServerCertificate(const DeleteServerCertificateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DeleteRulesOutcome(endpointOutcome.error());
+		return DeleteServerCertificateOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DeleteRulesOutcome(DeleteRulesResult(outcome.result()));
+		return DeleteServerCertificateOutcome(DeleteServerCertificateResult(outcome.result()));
 	else
-		return DeleteRulesOutcome(outcome.error());
+		return DeleteServerCertificateOutcome(outcome.error());
 }
 
-void SlbClient::deleteRulesAsync(const DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SlbClient::deleteServerCertificateAsync(const DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, deleteRules(request), context);
+		handler(this, request, deleteServerCertificate(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SlbClient::DeleteRulesOutcomeCallable SlbClient::deleteRulesCallable(const DeleteRulesRequest &request) const
+SlbClient::DeleteServerCertificateOutcomeCallable SlbClient::deleteServerCertificateCallable(const DeleteServerCertificateRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DeleteRulesOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DeleteServerCertificateOutcome()>>(
 			[this, request]()
 			{
-			return this->deleteRules(request);
+			return this->deleteServerCertificate(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-SlbClient::DeleteServerCertificateOutcome SlbClient::deleteServerCertificate(const DeleteServerCertificateRequest &request) const
+SlbClient::DeleteTLSCipherPolicyOutcome SlbClient::deleteTLSCipherPolicy(const DeleteTLSCipherPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DeleteServerCertificateOutcome(endpointOutcome.error());
+		return DeleteTLSCipherPolicyOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DeleteServerCertificateOutcome(DeleteServerCertificateResult(outcome.result()));
+		return DeleteTLSCipherPolicyOutcome(DeleteTLSCipherPolicyResult(outcome.result()));
 	else
-		return DeleteServerCertificateOutcome(outcome.error());
+		return DeleteTLSCipherPolicyOutcome(outcome.error());
 }
 
-void SlbClient::deleteServerCertificateAsync(const DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SlbClient::deleteTLSCipherPolicyAsync(const DeleteTLSCipherPolicyRequest& request, const DeleteTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, deleteServerCertificate(request), context);
+		handler(this, request, deleteTLSCipherPolicy(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SlbClient::DeleteServerCertificateOutcomeCallable SlbClient::deleteServerCertificateCallable(const DeleteServerCertificateRequest &request) const
+SlbClient::DeleteTLSCipherPolicyOutcomeCallable SlbClient::deleteTLSCipherPolicyCallable(const DeleteTLSCipherPolicyRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DeleteServerCertificateOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<DeleteTLSCipherPolicyOutcome()>>(
 			[this, request]()
 			{
-			return this->deleteServerCertificate(request);
+			return this->deleteTLSCipherPolicy(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -1383,42 +1383,6 @@ SlbClient::DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::
 	return task->get_future();
 }
 
-SlbClient::DescribeLoadBalancerListenersExOutcome SlbClient::describeLoadBalancerListenersEx(const DescribeLoadBalancerListenersExRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeLoadBalancerListenersExOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeLoadBalancerListenersExOutcome(DescribeLoadBalancerListenersExResult(outcome.result()));
-	else
-		return DescribeLoadBalancerListenersExOutcome(outcome.error());
-}
-
-void SlbClient::describeLoadBalancerListenersExAsync(const DescribeLoadBalancerListenersExRequest& request, const DescribeLoadBalancerListenersExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeLoadBalancerListenersEx(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SlbClient::DescribeLoadBalancerListenersExOutcomeCallable SlbClient::describeLoadBalancerListenersExCallable(const DescribeLoadBalancerListenersExRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeLoadBalancerListenersExOutcome()>>(
-			[this, request]()
-			{
-			return this->describeLoadBalancerListenersEx(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SlbClient::DescribeLoadBalancerTCPListenerAttributeOutcome SlbClient::describeLoadBalancerTCPListenerAttribute(const DescribeLoadBalancerTCPListenerAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1599,78 +1563,6 @@ SlbClient::DescribeMasterSlaveServerGroupsOutcomeCallable SlbClient::describeMas
 	return task->get_future();
 }
 
-SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcome SlbClient::describeMasterSlaveVServerGroupAttribute(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeMasterSlaveVServerGroupAttributeOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeMasterSlaveVServerGroupAttributeOutcome(DescribeMasterSlaveVServerGroupAttributeResult(outcome.result()));
-	else
-		return DescribeMasterSlaveVServerGroupAttributeOutcome(outcome.error());
-}
-
-void SlbClient::describeMasterSlaveVServerGroupAttributeAsync(const DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeMasterSlaveVServerGroupAttribute(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SlbClient::DescribeMasterSlaveVServerGroupAttributeOutcomeCallable SlbClient::describeMasterSlaveVServerGroupAttributeCallable(const DescribeMasterSlaveVServerGroupAttributeRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeMasterSlaveVServerGroupAttributeOutcome()>>(
-			[this, request]()
-			{
-			return this->describeMasterSlaveVServerGroupAttribute(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
-SlbClient::DescribeMasterSlaveVServerGroupsOutcome SlbClient::describeMasterSlaveVServerGroups(const DescribeMasterSlaveVServerGroupsRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return DescribeMasterSlaveVServerGroupsOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return DescribeMasterSlaveVServerGroupsOutcome(DescribeMasterSlaveVServerGroupsResult(outcome.result()));
-	else
-		return DescribeMasterSlaveVServerGroupsOutcome(outcome.error());
-}
-
-void SlbClient::describeMasterSlaveVServerGroupsAsync(const DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, describeMasterSlaveVServerGroups(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-SlbClient::DescribeMasterSlaveVServerGroupsOutcomeCallable SlbClient::describeMasterSlaveVServerGroupsCallable(const DescribeMasterSlaveVServerGroupsRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<DescribeMasterSlaveVServerGroupsOutcome()>>(
-			[this, request]()
-			{
-			return this->describeMasterSlaveVServerGroups(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 SlbClient::DescribeRegionsOutcome SlbClient::describeRegions(const DescribeRegionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +1851,42 @@ SlbClient::DescribeZonesOutcomeCallable SlbClient::describeZonesCallable(const D
 	return task->get_future();
 }
 
+SlbClient::ListTLSCipherPoliciesOutcome SlbClient::listTLSCipherPolicies(const ListTLSCipherPoliciesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTLSCipherPoliciesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTLSCipherPoliciesOutcome(ListTLSCipherPoliciesResult(outcome.result()));
+	else
+		return ListTLSCipherPoliciesOutcome(outcome.error());
+}
+
+void SlbClient::listTLSCipherPoliciesAsync(const ListTLSCipherPoliciesRequest& request, const ListTLSCipherPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTLSCipherPolicies(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::ListTLSCipherPoliciesOutcomeCallable SlbClient::listTLSCipherPoliciesCallable(const ListTLSCipherPoliciesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTLSCipherPoliciesOutcome()>>(
+			[this, request]()
+			{
+			return this->listTLSCipherPolicies(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::ListTagResourcesOutcome SlbClient::listTagResources(const ListTagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2607,36 +2535,36 @@ SlbClient::SetLoadBalancerHTTPSListenerAttributeOutcomeCallable SlbClient::setLo
 	return task->get_future();
 }
 
-SlbClient::SetLoadBalancerListenerAttributeExOutcome SlbClient::setLoadBalancerListenerAttributeEx(const SetLoadBalancerListenerAttributeExRequest &request) const
+SlbClient::SetLoadBalancerModificationProtectionOutcome SlbClient::setLoadBalancerModificationProtection(const SetLoadBalancerModificationProtectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return SetLoadBalancerListenerAttributeExOutcome(endpointOutcome.error());
+		return SetLoadBalancerModificationProtectionOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return SetLoadBalancerListenerAttributeExOutcome(SetLoadBalancerListenerAttributeExResult(outcome.result()));
+		return SetLoadBalancerModificationProtectionOutcome(SetLoadBalancerModificationProtectionResult(outcome.result()));
 	else
-		return SetLoadBalancerListenerAttributeExOutcome(outcome.error());
+		return SetLoadBalancerModificationProtectionOutcome(outcome.error());
 }
 
-void SlbClient::setLoadBalancerListenerAttributeExAsync(const SetLoadBalancerListenerAttributeExRequest& request, const SetLoadBalancerListenerAttributeExAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void SlbClient::setLoadBalancerModificationProtectionAsync(const SetLoadBalancerModificationProtectionRequest& request, const SetLoadBalancerModificationProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, setLoadBalancerListenerAttributeEx(request), context);
+		handler(this, request, setLoadBalancerModificationProtection(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-SlbClient::SetLoadBalancerListenerAttributeExOutcomeCallable SlbClient::setLoadBalancerListenerAttributeExCallable(const SetLoadBalancerListenerAttributeExRequest &request) const
+SlbClient::SetLoadBalancerModificationProtectionOutcomeCallable SlbClient::setLoadBalancerModificationProtectionCallable(const SetLoadBalancerModificationProtectionRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<SetLoadBalancerListenerAttributeExOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<SetLoadBalancerModificationProtectionOutcome()>>(
 			[this, request]()
 			{
-			return this->setLoadBalancerListenerAttributeEx(request);
+			return this->setLoadBalancerModificationProtection(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -2859,6 +2787,42 @@ SlbClient::SetServerCertificateNameOutcomeCallable SlbClient::setServerCertifica
 	return task->get_future();
 }
 
+SlbClient::SetTLSCipherPolicyAttributeOutcome SlbClient::setTLSCipherPolicyAttribute(const SetTLSCipherPolicyAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetTLSCipherPolicyAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetTLSCipherPolicyAttributeOutcome(SetTLSCipherPolicyAttributeResult(outcome.result()));
+	else
+		return SetTLSCipherPolicyAttributeOutcome(outcome.error());
+}
+
+void SlbClient::setTLSCipherPolicyAttributeAsync(const SetTLSCipherPolicyAttributeRequest& request, const SetTLSCipherPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setTLSCipherPolicyAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SlbClient::SetTLSCipherPolicyAttributeOutcomeCallable SlbClient::setTLSCipherPolicyAttributeCallable(const SetTLSCipherPolicyAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetTLSCipherPolicyAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->setTLSCipherPolicyAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SlbClient::SetVServerGroupAttributeOutcome SlbClient::setVServerGroupAttribute(const SetVServerGroupAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

slb/src/model/CreateDomainExtensionRequest.cc

@@ -49,6 +49,23 @@ void CreateDomainExtensionRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::vector<CreateDomainExtensionRequest::ServerCertificate> CreateDomainExtensionRequest::getServerCertificate()const
+{
+	return serverCertificate_;
+}
+
+void CreateDomainExtensionRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
+{
+	serverCertificate_ = serverCertificate;
+	for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
+		auto serverCertificateObj = serverCertificate.at(dep1);
+		std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
+		setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
+		setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
+		setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
+	}
+}
+
 std::string CreateDomainExtensionRequest::getRegionId()const
 {
 	return regionId_;
@@ -93,6 +110,19 @@ void CreateDomainExtensionRequest::setOwnerAccount(const std::string& ownerAccou
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::vector<std::string> CreateDomainExtensionRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void CreateDomainExtensionRequest::setCertificateId(const std::vector<std::string>& certificateId)
+{
+	certificateId_ = certificateId;
+	for(int dep1 = 0; dep1!= certificateId.size(); dep1++) {
+		setParameter("CertificateId."+ std::to_string(dep1), certificateId.at(dep1));
+	}
+}
+
 long CreateDomainExtensionRequest::getOwnerId()const
 {
 	return ownerId_;

slb/src/model/CreateLoadBalancerHTTPSListenerRequest.cc

@@ -38,6 +38,23 @@ void CreateLoadBalancerHTTPSListenerRequest::setResourceOwnerId(long resourceOwn
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::vector<CreateLoadBalancerHTTPSListenerRequest::ServerCertificate> CreateLoadBalancerHTTPSListenerRequest::getServerCertificate()const
+{
+	return serverCertificate_;
+}
+
+void CreateLoadBalancerHTTPSListenerRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
+{
+	serverCertificate_ = serverCertificate;
+	for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
+		auto serverCertificateObj = serverCertificate.at(dep1);
+		std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
+		setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
+		setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
+		setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
+	}
+}
+
 int CreateLoadBalancerHTTPSListenerRequest::getHealthCheckTimeout()const
 {
 	return healthCheckTimeout_;

slb/src/model/CreateLoadBalancerRequest.cc

@@ -27,6 +27,149 @@ CreateLoadBalancerRequest::CreateLoadBalancerRequest() :
 CreateLoadBalancerRequest::~CreateLoadBalancerRequest()
 {}
 
+long CreateLoadBalancerRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateLoadBalancerRequest::getAddressIPVersion()const
+{
+	return addressIPVersion_;
+}
+
+void CreateLoadBalancerRequest::setAddressIPVersion(const std::string& addressIPVersion)
+{
+	addressIPVersion_ = addressIPVersion;
+	setParameter("AddressIPVersion", addressIPVersion);
+}
+
+std::string CreateLoadBalancerRequest::getMasterZoneId()const
+{
+	return masterZoneId_;
+}
+
+void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
+{
+	masterZoneId_ = masterZoneId;
+	setParameter("MasterZoneId", masterZoneId);
+}
+
+std::string CreateLoadBalancerRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateLoadBalancerRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string CreateLoadBalancerRequest::getLoadBalancerName()const
+{
+	return loadBalancerName_;
+}
+
+void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalancerName)
+{
+	loadBalancerName_ = loadBalancerName;
+	setParameter("LoadBalancerName", loadBalancerName);
+}
+
+std::string CreateLoadBalancerRequest::getSlaveZoneId()const
+{
+	return slaveZoneId_;
+}
+
+void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
+{
+	slaveZoneId_ = slaveZoneId;
+	setParameter("SlaveZoneId", slaveZoneId);
+}
+
+std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
+{
+	return loadBalancerSpec_;
+}
+
+void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec)
+{
+	loadBalancerSpec_ = loadBalancerSpec;
+	setParameter("LoadBalancerSpec", loadBalancerSpec);
+}
+
+long CreateLoadBalancerRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateLoadBalancerRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateLoadBalancerRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateLoadBalancerRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+
+std::string CreateLoadBalancerRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
+{
+	return enableVpcVipFlow_;
+}
+
+void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow)
+{
+	enableVpcVipFlow_ = enableVpcVipFlow;
+	setParameter("EnableVpcVipFlow", enableVpcVipFlow);
+}
+
+std::string CreateLoadBalancerRequest::getInternetChargeType()const
+{
+	return internetChargeType_;
+}
+
+void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType)
+{
+	internetChargeType_ = internetChargeType;
+	setParameter("InternetChargeType", internetChargeType);
+}
+
+std::string CreateLoadBalancerRequest::getPricingCycle()const
+{
+	return pricingCycle_;
+}
+
+void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle)
+{
+	pricingCycle_ = pricingCycle;
+	setParameter("PricingCycle", pricingCycle);
+}
+
 std::string CreateLoadBalancerRequest::getAccess_key_id()const
 {
 	return access_key_id_;
@@ -38,15 +181,15 @@ void CreateLoadBalancerRequest::setAccess_key_id(const std::string& access_key_i
 	setParameter("Access_key_id", access_key_id);
 }
 
-long CreateLoadBalancerRequest::getResourceOwnerId()const
+std::string CreateLoadBalancerRequest::getModificationProtectionReason()const
 {
-	return resourceOwnerId_;
+	return modificationProtectionReason_;
 }
 
-void CreateLoadBalancerRequest::setResourceOwnerId(long resourceOwnerId)
+void CreateLoadBalancerRequest::setModificationProtectionReason(const std::string& modificationProtectionReason)
 {
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+	modificationProtectionReason_ = modificationProtectionReason;
+	setParameter("ModificationProtectionReason", modificationProtectionReason);
 }
 
 bool CreateLoadBalancerRequest::getSupportPrivateLink()const
@@ -82,28 +225,6 @@ void CreateLoadBalancerRequest::setCloudType(const std::string& cloudType)
 	setParameter("CloudType", cloudType);
 }
 
-std::string CreateLoadBalancerRequest::getAddressIPVersion()const
-{
-	return addressIPVersion_;
-}
-
-void CreateLoadBalancerRequest::setAddressIPVersion(const std::string& addressIPVersion)
-{
-	addressIPVersion_ = addressIPVersion;
-	setParameter("AddressIPVersion", addressIPVersion);
-}
-
-std::string CreateLoadBalancerRequest::getMasterZoneId()const
-{
-	return masterZoneId_;
-}
-
-void CreateLoadBalancerRequest::setMasterZoneId(const std::string& masterZoneId)
-{
-	masterZoneId_ = masterZoneId;
-	setParameter("MasterZoneId", masterZoneId);
-}
-
 int CreateLoadBalancerRequest::getDuration()const
 {
 	return duration_;
@@ -115,28 +236,6 @@ void CreateLoadBalancerRequest::setDuration(int duration)
 	setParameter("Duration", std::to_string(duration));
 }
 
-std::string CreateLoadBalancerRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
-}
-
-void CreateLoadBalancerRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
-}
-
-std::string CreateLoadBalancerRequest::getLoadBalancerName()const
-{
-	return loadBalancerName_;
-}
-
-void CreateLoadBalancerRequest::setLoadBalancerName(const std::string& loadBalancerName)
-{
-	loadBalancerName_ = loadBalancerName;
-	setParameter("LoadBalancerName", loadBalancerName);
-}
-
 std::string CreateLoadBalancerRequest::getRegionId()const
 {
 	return regionId_;
@@ -159,17 +258,6 @@ void CreateLoadBalancerRequest::setAddressType(const std::string& addressType)
 	setParameter("AddressType", addressType);
 }
 
-std::string CreateLoadBalancerRequest::getSlaveZoneId()const
-{
-	return slaveZoneId_;
-}
-
-void CreateLoadBalancerRequest::setSlaveZoneId(const std::string& slaveZoneId)
-{
-	slaveZoneId_ = slaveZoneId;
-	setParameter("SlaveZoneId", slaveZoneId);
-}
-
 std::string CreateLoadBalancerRequest::getDeleteProtection()const
 {
 	return deleteProtection_;
@@ -181,17 +269,6 @@ void CreateLoadBalancerRequest::setDeleteProtection(const std::string& deletePro
 	setParameter("DeleteProtection", deleteProtection);
 }
 
-std::string CreateLoadBalancerRequest::getLoadBalancerSpec()const
-{
-	return loadBalancerSpec_;
-}
-
-void CreateLoadBalancerRequest::setLoadBalancerSpec(const std::string& loadBalancerSpec)
-{
-	loadBalancerSpec_ = loadBalancerSpec;
-	setParameter("LoadBalancerSpec", loadBalancerSpec);
-}
-
 bool CreateLoadBalancerRequest::getAutoPay()const
 {
 	return autoPay_;
@@ -247,59 +324,15 @@ void CreateLoadBalancerRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
-long CreateLoadBalancerRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CreateLoadBalancerRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string CreateLoadBalancerRequest::getTags()const
-{
-	return tags_;
-}
-
-void CreateLoadBalancerRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setParameter("Tags", tags);
-}
-
-std::string CreateLoadBalancerRequest::getVSwitchId()const
-{
-	return vSwitchId_;
-}
-
-void CreateLoadBalancerRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
-}
-
-std::string CreateLoadBalancerRequest::getEnableVpcVipFlow()const
-{
-	return enableVpcVipFlow_;
-}
-
-void CreateLoadBalancerRequest::setEnableVpcVipFlow(const std::string& enableVpcVipFlow)
-{
-	enableVpcVipFlow_ = enableVpcVipFlow;
-	setParameter("EnableVpcVipFlow", enableVpcVipFlow);
-}
-
-std::string CreateLoadBalancerRequest::getInternetChargeType()const
+std::string CreateLoadBalancerRequest::getModificationProtectionStatus()const
 {
-	return internetChargeType_;
+	return modificationProtectionStatus_;
 }
 
-void CreateLoadBalancerRequest::setInternetChargeType(const std::string& internetChargeType)
+void CreateLoadBalancerRequest::setModificationProtectionStatus(const std::string& modificationProtectionStatus)
 {
-	internetChargeType_ = internetChargeType;
-	setParameter("InternetChargeType", internetChargeType);
+	modificationProtectionStatus_ = modificationProtectionStatus;
+	setParameter("ModificationProtectionStatus", modificationProtectionStatus);
 }
 
 std::string CreateLoadBalancerRequest::getVpcId()const
@@ -324,17 +357,6 @@ void CreateLoadBalancerRequest::setPayType(const std::string& payType)
 	setParameter("PayType", payType);
 }
 
-std::string CreateLoadBalancerRequest::getPricingCycle()const
-{
-	return pricingCycle_;
-}
-
-void CreateLoadBalancerRequest::setPricingCycle(const std::string& pricingCycle)
-{
-	pricingCycle_ = pricingCycle;
-	setParameter("PricingCycle", pricingCycle);
-}
-
 int CreateLoadBalancerRequest::getRatio()const
 {
 	return ratio_;

slb/src/model/CreateMasterSlaveVServerGroupRequest.cc

@@ -1,148 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/CreateMasterSlaveVServerGroupRequest.h>
-
-using AlibabaCloud::Slb::Model::CreateMasterSlaveVServerGroupRequest;
-
-CreateMasterSlaveVServerGroupRequest::CreateMasterSlaveVServerGroupRequest() :
-	RpcServiceRequest("slb", "2014-05-15", "CreateMasterSlaveVServerGroup")
-{}
-
-CreateMasterSlaveVServerGroupRequest::~CreateMasterSlaveVServerGroupRequest()
-{}
-
-std::string CreateMasterSlaveVServerGroupRequest::getAccess_key_id()const
-{
-	return access_key_id_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id)
-{
-	access_key_id_ = access_key_id;
-	setCoreParameter("Access_key_id", access_key_id);
-}
-
-long CreateMasterSlaveVServerGroupRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers)
-{
-	masterSlaveBackendServers_ = masterSlaveBackendServers;
-	setCoreParameter("MasterSlaveBackendServers", masterSlaveBackendServers);
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setCoreParameter("RegionId", regionId);
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupName()const
-{
-	return masterSlaveVServerGroupName_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName)
-{
-	masterSlaveVServerGroupName_ = masterSlaveVServerGroupName;
-	setCoreParameter("MasterSlaveVServerGroupName", masterSlaveVServerGroupName);
-}
-
-long CreateMasterSlaveVServerGroupRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getTags()const
-{
-	return tags_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setCoreParameter("Tags", tags);
-}
-
-std::string CreateMasterSlaveVServerGroupRequest::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-void CreateMasterSlaveVServerGroupRequest::setLoadBalancerId(const std::string& loadBalancerId)
-{
-	loadBalancerId_ = loadBalancerId;
-	setCoreParameter("LoadBalancerId", loadBalancerId);
-}
-

slb/src/model/CreateMasterSlaveVServerGroupResult.cc

@@ -1,80 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/CreateMasterSlaveVServerGroupResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Slb;
-using namespace AlibabaCloud::Slb::Model;
-
-CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult() :
-	ServiceResult()
-{}
-
-CreateMasterSlaveVServerGroupResult::CreateMasterSlaveVServerGroupResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-CreateMasterSlaveVServerGroupResult::~CreateMasterSlaveVServerGroupResult()
-{}
-
-void CreateMasterSlaveVServerGroupResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
-	for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
-	{
-		MasterSlaveBackendServer masterSlaveBackendServersObject;
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
-			masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
-			masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
-			masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].isNull())
-			masterSlaveBackendServersObject.isBackup = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].asString());
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
-			masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
-			masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].isNull())
-			masterSlaveBackendServersObject.eniHost = valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
-			masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
-			masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
-		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
-	}
-	if(!value["MasterSlaveVServerGroupId"].isNull())
-		masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
-
-}
-
-std::string CreateMasterSlaveVServerGroupResult::getMasterSlaveVServerGroupId()const
-{
-	return masterSlaveVServerGroupId_;
-}
-
-std::vector<CreateMasterSlaveVServerGroupResult::MasterSlaveBackendServer> CreateMasterSlaveVServerGroupResult::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-

slb/src/model/CreateTLSCipherPolicyRequest.cc

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/slb/model/CreateTLSCipherPolicyRequest.h>
+
+using AlibabaCloud::Slb::Model::CreateTLSCipherPolicyRequest;
+
+CreateTLSCipherPolicyRequest::CreateTLSCipherPolicyRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "CreateTLSCipherPolicy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateTLSCipherPolicyRequest::~CreateTLSCipherPolicyRequest()
+{}
+
+std::string CreateTLSCipherPolicyRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void CreateTLSCipherPolicyRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long CreateTLSCipherPolicyRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CreateTLSCipherPolicyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateTLSCipherPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateTLSCipherPolicyRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateTLSCipherPolicyRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<std::string> CreateTLSCipherPolicyRequest::getCiphers()const
+{
+	return ciphers_;
+}
+
+void CreateTLSCipherPolicyRequest::setCiphers(const std::vector<std::string>& ciphers)
+{
+	ciphers_ = ciphers;
+	for(int dep1 = 0; dep1!= ciphers.size(); dep1++) {
+		setParameter("Ciphers."+ std::to_string(dep1), ciphers.at(dep1));
+	}
+}
+
+std::vector<std::string> CreateTLSCipherPolicyRequest::getTLSVersions()const
+{
+	return tLSVersions_;
+}
+
+void CreateTLSCipherPolicyRequest::setTLSVersions(const std::vector<std::string>& tLSVersions)
+{
+	tLSVersions_ = tLSVersions;
+	for(int dep1 = 0; dep1!= tLSVersions.size(); dep1++) {
+		setParameter("TLSVersions."+ std::to_string(dep1), tLSVersions.at(dep1));
+	}
+}
+
+std::string CreateTLSCipherPolicyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateTLSCipherPolicyRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateTLSCipherPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateTLSCipherPolicyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateTLSCipherPolicyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateTLSCipherPolicyRequest::getName()const
+{
+	return name_;
+}
+
+void CreateTLSCipherPolicyRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+

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

slb/src/model/DeleteMasterSlaveVServerGroupRequest.cc

@@ -1,126 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DeleteMasterSlaveVServerGroupRequest.h>
-
-using AlibabaCloud::Slb::Model::DeleteMasterSlaveVServerGroupRequest;
-
-DeleteMasterSlaveVServerGroupRequest::DeleteMasterSlaveVServerGroupRequest() :
-	RpcServiceRequest("slb", "2014-05-15", "DeleteMasterSlaveVServerGroup")
-{}
-
-DeleteMasterSlaveVServerGroupRequest::~DeleteMasterSlaveVServerGroupRequest()
-{}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getAccess_key_id()const
-{
-	return access_key_id_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setAccess_key_id(const std::string& access_key_id)
-{
-	access_key_id_ = access_key_id;
-	setCoreParameter("Access_key_id", access_key_id);
-}
-
-long DeleteMasterSlaveVServerGroupRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
-}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setCoreParameter("RegionId", regionId);
-}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getMasterSlaveVServerGroupId()const
-{
-	return masterSlaveVServerGroupId_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
-{
-	masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
-	setCoreParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId);
-}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
-}
-
-long DeleteMasterSlaveVServerGroupRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string DeleteMasterSlaveVServerGroupRequest::getTags()const
-{
-	return tags_;
-}
-
-void DeleteMasterSlaveVServerGroupRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setCoreParameter("Tags", tags);
-}
-

slb/src/model/DeleteTLSCipherPolicyRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/slb/model/DeleteTLSCipherPolicyRequest.h>
+
+using AlibabaCloud::Slb::Model::DeleteTLSCipherPolicyRequest;
+
+DeleteTLSCipherPolicyRequest::DeleteTLSCipherPolicyRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "DeleteTLSCipherPolicy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTLSCipherPolicyRequest::~DeleteTLSCipherPolicyRequest()
+{}
+
+std::string DeleteTLSCipherPolicyRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DeleteTLSCipherPolicyRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long DeleteTLSCipherPolicyRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DeleteTLSCipherPolicyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getTLSCipherPolicyId()const
+{
+	return tLSCipherPolicyId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
+{
+	tLSCipherPolicyId_ = tLSCipherPolicyId;
+	setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DeleteTLSCipherPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DeleteTLSCipherPolicyRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DeleteTLSCipherPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DeleteTLSCipherPolicyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteTLSCipherPolicyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

slb/src/model/DeleteMasterSlaveVServerGroupResult.cc → slb/src/model/DeleteTLSCipherPolicyResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h>
+#include <alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Slb;
 using namespace AlibabaCloud::Slb::Model;
 
-DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult() :
+DeleteTLSCipherPolicyResult::DeleteTLSCipherPolicyResult() :
 	ServiceResult()
 {}
 
-DeleteMasterSlaveVServerGroupResult::DeleteMasterSlaveVServerGroupResult(const std::string &payload) :
+DeleteTLSCipherPolicyResult::DeleteTLSCipherPolicyResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-DeleteMasterSlaveVServerGroupResult::~DeleteMasterSlaveVServerGroupResult()
+DeleteTLSCipherPolicyResult::~DeleteTLSCipherPolicyResult()
 {}
 
-void DeleteMasterSlaveVServerGroupResult::parse(const std::string &payload)
+void DeleteTLSCipherPolicyResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

slb/src/model/DescribeAccessControlListsResult.cc

@@ -51,14 +51,14 @@ void DescribeAccessControlListsResult::parse(const std::string &payload)
 			aclsObject.addressIPVersion = valueAclsAcl["AddressIPVersion"].asString();
 		if(!valueAclsAcl["ResourceGroupId"].isNull())
 			aclsObject.resourceGroupId = valueAclsAcl["ResourceGroupId"].asString();
-		auto allTagsNode = allAclsNode["Tags"]["Tag"];
-		for (auto allAclsNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueAclsAcl["Tags"]["Tag"];
+		for (auto valueAclsAclTagsTag : allTagsNode)
 		{
 			Acl::Tag tagsObject;
-			if(!allAclsNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allAclsNodeTagsTag["TagKey"].asString();
-			if(!allAclsNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allAclsNodeTagsTag["TagValue"].asString();
+			if(!valueAclsAclTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueAclsAclTagsTag["TagKey"].asString();
+			if(!valueAclsAclTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueAclsAclTagsTag["TagValue"].asString();
 			aclsObject.tags.push_back(tagsObject);
 		}
 		acls_.push_back(aclsObject);

slb/src/model/DescribeAvailableResourceResult.cc

@@ -47,14 +47,14 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 			availableResourcesObject.masterZoneId = valueAvailableResourcesAvailableResource["MasterZoneId"].asString();
 		if(!valueAvailableResourcesAvailableResource["SlaveZoneId"].isNull())
 			availableResourcesObject.slaveZoneId = valueAvailableResourcesAvailableResource["SlaveZoneId"].asString();
-		auto allSupportResourcesNode = allAvailableResourcesNode["SupportResources"]["SupportResource"];
-		for (auto allAvailableResourcesNodeSupportResourcesSupportResource : allSupportResourcesNode)
+		auto allSupportResourcesNode = valueAvailableResourcesAvailableResource["SupportResources"]["SupportResource"];
+		for (auto valueAvailableResourcesAvailableResourceSupportResourcesSupportResource : allSupportResourcesNode)
 		{
 			AvailableResource::SupportResource supportResourcesObject;
-			if(!allAvailableResourcesNodeSupportResourcesSupportResource["AddressType"].isNull())
-				supportResourcesObject.addressType = allAvailableResourcesNodeSupportResourcesSupportResource["AddressType"].asString();
-			if(!allAvailableResourcesNodeSupportResourcesSupportResource["AddressIPVersion"].isNull())
-				supportResourcesObject.addressIPVersion = allAvailableResourcesNodeSupportResourcesSupportResource["AddressIPVersion"].asString();
+			if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].isNull())
+				supportResourcesObject.addressType = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressType"].asString();
+			if(!valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].isNull())
+				supportResourcesObject.addressIPVersion = valueAvailableResourcesAvailableResourceSupportResourcesSupportResource["AddressIPVersion"].asString();
 			availableResourcesObject.supportResources.push_back(supportResourcesObject);
 		}
 		availableResources_.push_back(availableResourcesObject);

slb/src/model/DescribeCACertificatesResult.cc

@@ -63,14 +63,20 @@ void DescribeCACertificatesResult::parse(const std::string &payload)
 			cACertificatesObject.expireTimeStamp = std::stol(valueCACertificatesCACertificate["ExpireTimeStamp"].asString());
 		if(!valueCACertificatesCACertificate["CommonName"].isNull())
 			cACertificatesObject.commonName = valueCACertificatesCACertificate["CommonName"].asString();
-		auto allTagsNode = allCACertificatesNode["Tags"]["Tag"];
-		for (auto allCACertificatesNodeTagsTag : allTagsNode)
+		if(!valueCACertificatesCACertificate["EncryptionAlgorithm"].isNull())
+			cACertificatesObject.encryptionAlgorithm = valueCACertificatesCACertificate["EncryptionAlgorithm"].asString();
+		if(!valueCACertificatesCACertificate["EncryptionKeyLength"].isNull())
+			cACertificatesObject.encryptionKeyLength = std::stoi(valueCACertificatesCACertificate["EncryptionKeyLength"].asString());
+		if(!valueCACertificatesCACertificate["StandardType"].isNull())
+			cACertificatesObject.standardType = valueCACertificatesCACertificate["StandardType"].asString();
+		auto allTagsNode = valueCACertificatesCACertificate["Tags"]["Tag"];
+		for (auto valueCACertificatesCACertificateTagsTag : allTagsNode)
 		{
 			CACertificate::Tag tagsObject;
-			if(!allCACertificatesNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allCACertificatesNodeTagsTag["TagKey"].asString();
-			if(!allCACertificatesNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allCACertificatesNodeTagsTag["TagValue"].asString();
+			if(!valueCACertificatesCACertificateTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueCACertificatesCACertificateTagsTag["TagKey"].asString();
+			if(!valueCACertificatesCACertificateTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueCACertificatesCACertificateTagsTag["TagValue"].asString();
 			cACertificatesObject.tags.push_back(tagsObject);
 		}
 		cACertificates_.push_back(cACertificatesObject);

slb/src/model/DescribeDomainExtensionAttributeResult.cc

@@ -39,6 +39,30 @@ void DescribeDomainExtensionAttributeResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allCertificatesNode = value["Certificates"]["Certificate"];
+	for (auto valueCertificatesCertificate : allCertificatesNode)
+	{
+		Certificate certificatesObject;
+		if(!valueCertificatesCertificate["CertificateId"].isNull())
+			certificatesObject.certificateId = valueCertificatesCertificate["CertificateId"].asString();
+		if(!valueCertificatesCertificate["EncryptionAlgorithm"].isNull())
+			certificatesObject.encryptionAlgorithm = valueCertificatesCertificate["EncryptionAlgorithm"].asString();
+		certificates_.push_back(certificatesObject);
+	}
+	auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
+	for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
+	{
+		ServerCertificate serverCertificatesObject;
+		if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
+			serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
+		if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+			serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+		if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
+			serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
+		if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
+			serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
+		serverCertificates_.push_back(serverCertificatesObject);
+	}
 	if(!value["DomainExtensionId"].isNull())
 		domainExtensionId_ = value["DomainExtensionId"].asString();
 	if(!value["Domain"].isNull())
@@ -62,6 +86,16 @@ int DescribeDomainExtensionAttributeResult::getListenerPort()const
 	return listenerPort_;
 }
 
+std::vector<DescribeDomainExtensionAttributeResult::Certificate> DescribeDomainExtensionAttributeResult::getCertificates()const
+{
+	return certificates_;
+}
+
+std::vector<DescribeDomainExtensionAttributeResult::ServerCertificate> DescribeDomainExtensionAttributeResult::getServerCertificates()const
+{
+	return serverCertificates_;
+}
+
 std::string DescribeDomainExtensionAttributeResult::getServerCertificateId()const
 {
 	return serverCertificateId_;

slb/src/model/DescribeDomainExtensionsResult.cc

@@ -49,6 +49,30 @@ void DescribeDomainExtensionsResult::parse(const std::string &payload)
 			domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
 		if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
 			domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
+		auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
+		for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
+		{
+			DomainExtension::Certificate certificatesObject;
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
+				certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
+				certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
+			domainExtensionsObject.certificates.push_back(certificatesObject);
+		}
+		auto allServerCertificatesNode = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
+		for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificatesNode)
+		{
+			DomainExtension::ServerCertificate serverCertificatesObject;
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
+				serverCertificatesObject.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+				serverCertificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
+				serverCertificatesObject.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
+				serverCertificatesObject.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
+			domainExtensionsObject.serverCertificates.push_back(serverCertificatesObject);
+		}
 		domainExtensions_.push_back(domainExtensionsObject);
 	}
 

slb/src/model/DescribeLoadBalancerAttributeResult.cc

@@ -169,6 +169,12 @@ void DescribeLoadBalancerAttributeResult::parse(const std::string &payload)
 		cloudInstanceUid_ = std::stol(value["CloudInstanceUid"].asString());
 	if(!value["SupportPrivateLink"].isNull())
 		supportPrivateLink_ = value["SupportPrivateLink"].asString() == "true";
+	if(!value["BusinessStatus"].isNull())
+		businessStatus_ = value["BusinessStatus"].asString();
+	if(!value["ModificationProtectionStatus"].isNull())
+		modificationProtectionStatus_ = value["ModificationProtectionStatus"].asString();
+	if(!value["ModificationProtectionReason"].isNull())
+		modificationProtectionReason_ = value["ModificationProtectionReason"].asString();
 
 }
 
@@ -232,11 +238,21 @@ std::string DescribeLoadBalancerAttributeResult::getHasReservedInfo()const
 	return hasReservedInfo_;
 }
 
+std::string DescribeLoadBalancerAttributeResult::getBusinessStatus()const
+{
+	return businessStatus_;
+}
+
 std::string DescribeLoadBalancerAttributeResult::getReservedInfoBandwidth()const
 {
 	return reservedInfoBandwidth_;
 }
 
+std::string DescribeLoadBalancerAttributeResult::getModificationProtectionStatus()const
+{
+	return modificationProtectionStatus_;
+}
+
 std::string DescribeLoadBalancerAttributeResult::getLoadBalancerSpec()const
 {
 	return loadBalancerSpec_;
@@ -252,6 +268,11 @@ int DescribeLoadBalancerAttributeResult::getBandwidth()const
 	return bandwidth_;
 }
 
+std::string DescribeLoadBalancerAttributeResult::getModificationProtectionReason()const
+{
+	return modificationProtectionReason_;
+}
+
 std::string DescribeLoadBalancerAttributeResult::getAssociatedCenId()const
 {
 	return associatedCenId_;

slb/src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc

@@ -65,8 +65,46 @@ void DescribeLoadBalancerHTTPSListenerAttributeResult::parse(const std::string &
 			domainExtensionsObject.domain = valueDomainExtensionsDomainExtension["Domain"].asString();
 		if(!valueDomainExtensionsDomainExtension["ServerCertificateId"].isNull())
 			domainExtensionsObject.serverCertificateId = valueDomainExtensionsDomainExtension["ServerCertificateId"].asString();
+		auto allCertificatesNode = valueDomainExtensionsDomainExtension["Certificates"]["Certificate"];
+		for (auto valueDomainExtensionsDomainExtensionCertificatesCertificate : allCertificatesNode)
+		{
+			DomainExtension::Certificate certificatesObject;
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].isNull())
+				certificatesObject.certificateId = valueDomainExtensionsDomainExtensionCertificatesCertificate["CertificateId"].asString();
+			if(!valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].isNull())
+				certificatesObject.encryptionAlgorithm = valueDomainExtensionsDomainExtensionCertificatesCertificate["EncryptionAlgorithm"].asString();
+			domainExtensionsObject.certificates.push_back(certificatesObject);
+		}
+		auto allServerCertificates1Node = valueDomainExtensionsDomainExtension["ServerCertificates"]["ServerCertificate"];
+		for (auto valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate : allServerCertificates1Node)
+		{
+			DomainExtension::ServerCertificate serverCertificates1Object;
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].isNull())
+				serverCertificates1Object.certificateId = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["CertificateId"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+				serverCertificates1Object.encryptionAlgorithm = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].isNull())
+				serverCertificates1Object.standardType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["StandardType"].asString();
+			if(!valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].isNull())
+				serverCertificates1Object.bindingType = valueDomainExtensionsDomainExtensionServerCertificatesServerCertificate["BindingType"].asString();
+			domainExtensionsObject.serverCertificates1.push_back(serverCertificates1Object);
+		}
 		domainExtensions_.push_back(domainExtensionsObject);
 	}
+	auto allServerCertificatesNode = value["ServerCertificates"]["ServerCertificate"];
+	for (auto valueServerCertificatesServerCertificate : allServerCertificatesNode)
+	{
+		ServerCertificate2 serverCertificatesObject;
+		if(!valueServerCertificatesServerCertificate["CertificateId"].isNull())
+			serverCertificatesObject.certificateId = valueServerCertificatesServerCertificate["CertificateId"].asString();
+		if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+			serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+		if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
+			serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
+		if(!valueServerCertificatesServerCertificate["BindingType"].isNull())
+			serverCertificatesObject.bindingType = valueServerCertificatesServerCertificate["BindingType"].asString();
+		serverCertificates_.push_back(serverCertificatesObject);
+	}
 	auto allAclIds = value["AclIds"]["AclId"];
 	for (const auto &item : allAclIds)
 		aclIds_.push_back(item.asString());
@@ -250,6 +288,11 @@ std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getCACertificateId
 	return cACertificateId_;
 }
 
+std::vector<DescribeLoadBalancerHTTPSListenerAttributeResult::ServerCertificate2> DescribeLoadBalancerHTTPSListenerAttributeResult::getServerCertificates()const
+{
+	return serverCertificates_;
+}
+
 std::string DescribeLoadBalancerHTTPSListenerAttributeResult::getXForwardedFor_ClientCertFingerprintAlias()const
 {
 	return xForwardedFor_ClientCertFingerprintAlias_;

slb/src/model/DescribeLoadBalancerListenersExRequest.cc

@@ -1,73 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DescribeLoadBalancerListenersExRequest.h>
-
-using AlibabaCloud::Slb::Model::DescribeLoadBalancerListenersExRequest;
-
-DescribeLoadBalancerListenersExRequest::DescribeLoadBalancerListenersExRequest() :
-	RpcServiceRequest("slb", "2014-05-15", "DescribeLoadBalancerListenersEx")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeLoadBalancerListenersExRequest::~DescribeLoadBalancerListenersExRequest()
-{}
-
-int DescribeLoadBalancerListenersExRequest::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-void DescribeLoadBalancerListenersExRequest::setListenerPort(int listenerPort)
-{
-	listenerPort_ = listenerPort;
-	setParameter("ListenerPort", std::to_string(listenerPort));
-}
-
-std::string DescribeLoadBalancerListenersExRequest::getProtocol()const
-{
-	return protocol_;
-}
-
-void DescribeLoadBalancerListenersExRequest::setProtocol(const std::string& protocol)
-{
-	protocol_ = protocol;
-	setParameter("Protocol", protocol);
-}
-
-std::string DescribeLoadBalancerListenersExRequest::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-void DescribeLoadBalancerListenersExRequest::setLoadBalancerId(const std::string& loadBalancerId)
-{
-	loadBalancerId_ = loadBalancerId;
-	setParameter("LoadBalancerId", loadBalancerId);
-}
-
-std::string DescribeLoadBalancerListenersExRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DescribeLoadBalancerListenersExRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-

slb/src/model/DescribeLoadBalancerListenersExResult.cc

@@ -1,68 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DescribeLoadBalancerListenersExResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Slb;
-using namespace AlibabaCloud::Slb::Model;
-
-DescribeLoadBalancerListenersExResult::DescribeLoadBalancerListenersExResult() :
-	ServiceResult()
-{}
-
-DescribeLoadBalancerListenersExResult::DescribeLoadBalancerListenersExResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeLoadBalancerListenersExResult::~DescribeLoadBalancerListenersExResult()
-{}
-
-void DescribeLoadBalancerListenersExResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allListenerExtendedAttributesNode = value["ListenerExtendedAttributes"]["ListenerAttributeExResponseModel"];
-	for (auto valueListenerExtendedAttributesListenerAttributeExResponseModel : allListenerExtendedAttributesNode)
-	{
-		ListenerAttributeExResponseModel listenerExtendedAttributesObject;
-		if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["ListenerPort"].isNull())
-			listenerExtendedAttributesObject.listenerPort = std::stoi(valueListenerExtendedAttributesListenerAttributeExResponseModel["ListenerPort"].asString());
-		if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["Protocol"].isNull())
-			listenerExtendedAttributesObject.protocol = valueListenerExtendedAttributesListenerAttributeExResponseModel["Protocol"].asString();
-		if(!valueListenerExtendedAttributesListenerAttributeExResponseModel["RecordCustomizedHeaders"].isNull())
-			listenerExtendedAttributesObject.recordCustomizedHeaders = valueListenerExtendedAttributesListenerAttributeExResponseModel["RecordCustomizedHeaders"].asString();
-		listenerExtendedAttributes_.push_back(listenerExtendedAttributesObject);
-	}
-	if(!value["LoadBalancerId"].isNull())
-		loadBalancerId_ = value["LoadBalancerId"].asString();
-
-}
-
-std::string DescribeLoadBalancerListenersExResult::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-std::vector<DescribeLoadBalancerListenersExResult::ListenerAttributeExResponseModel> DescribeLoadBalancerListenersExResult::getListenerExtendedAttributes()const
-{
-	return listenerExtendedAttributes_;
-}
-

slb/src/model/DescribeLoadBalancersRequest.cc

@@ -27,17 +27,6 @@ DescribeLoadBalancersRequest::DescribeLoadBalancersRequest() :
 DescribeLoadBalancersRequest::~DescribeLoadBalancersRequest()
 {}
 
-std::string DescribeLoadBalancersRequest::getAccess_key_id()const
-{
-	return access_key_id_;
-}
-
-void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id)
-{
-	access_key_id_ = access_key_id;
-	setParameter("Access_key_id", access_key_id);
-}
-
 long DescribeLoadBalancersRequest::getResourceOwnerId()const
 {
 	return resourceOwnerId_;
@@ -49,17 +38,6 @@ void DescribeLoadBalancersRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
-bool DescribeLoadBalancersRequest::getSupportPrivateLink()const
-{
-	return supportPrivateLink_;
-}
-
-void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink)
-{
-	supportPrivateLink_ = supportPrivateLink;
-	setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
-}
-
 std::string DescribeLoadBalancersRequest::getNetworkType()const
 {
 	return networkType_;
@@ -93,17 +71,6 @@ void DescribeLoadBalancersRequest::setMasterZoneId(const std::string& masterZone
 	setParameter("MasterZoneId", masterZoneId);
 }
 
-int DescribeLoadBalancersRequest::getPageNumber()const
-{
-	return pageNumber_;
-}
-
-void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
-}
-
 std::string DescribeLoadBalancersRequest::getResourceGroupId()const
 {
 	return resourceGroupId_;
@@ -126,39 +93,6 @@ void DescribeLoadBalancersRequest::setLoadBalancerName(const std::string& loadBa
 	setParameter("LoadBalancerName", loadBalancerName);
 }
 
-std::string DescribeLoadBalancersRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-
-int DescribeLoadBalancersRequest::getPageSize()const
-{
-	return pageSize_;
-}
-
-void DescribeLoadBalancersRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
-}
-
-std::string DescribeLoadBalancersRequest::getAddressType()const
-{
-	return addressType_;
-}
-
-void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType)
-{
-	addressType_ = addressType;
-	setParameter("AddressType", addressType);
-}
-
 std::string DescribeLoadBalancersRequest::getSlaveZoneId()const
 {
 	return slaveZoneId_;
@@ -186,50 +120,6 @@ void DescribeLoadBalancersRequest::setTag(const std::vector<Tag>& tag)
 	}
 }
 
-std::string DescribeLoadBalancersRequest::getFuzzy()const
-{
-	return fuzzy_;
-}
-
-void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
-{
-	fuzzy_ = fuzzy;
-	setParameter("Fuzzy", fuzzy);
-}
-
-std::string DescribeLoadBalancersRequest::getAddress()const
-{
-	return address_;
-}
-
-void DescribeLoadBalancersRequest::setAddress(const std::string& address)
-{
-	address_ = address;
-	setParameter("Address", address);
-}
-
-std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DescribeLoadBalancersRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
-}
-
 long DescribeLoadBalancersRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -252,17 +142,6 @@ void DescribeLoadBalancersRequest::setServerId(const std::string& serverId)
 	setParameter("ServerId", serverId);
 }
 
-std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
-{
-	return loadBalancerStatus_;
-}
-
-void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
-{
-	loadBalancerStatus_ = loadBalancerStatus;
-	setParameter("LoadBalancerStatus", loadBalancerStatus);
-}
-
 std::string DescribeLoadBalancersRequest::getTags()const
 {
 	return tags_;
@@ -318,6 +197,138 @@ void DescribeLoadBalancersRequest::setInternetChargeType(const std::string& inte
 	setParameter("InternetChargeType", internetChargeType);
 }
 
+std::string DescribeLoadBalancersRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void DescribeLoadBalancersRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+bool DescribeLoadBalancersRequest::getSupportPrivateLink()const
+{
+	return supportPrivateLink_;
+}
+
+void DescribeLoadBalancersRequest::setSupportPrivateLink(bool supportPrivateLink)
+{
+	supportPrivateLink_ = supportPrivateLink;
+	setParameter("SupportPrivateLink", supportPrivateLink ? "true" : "false");
+}
+
+int DescribeLoadBalancersRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeLoadBalancersRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeLoadBalancersRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeLoadBalancersRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int DescribeLoadBalancersRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeLoadBalancersRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeLoadBalancersRequest::getAddressType()const
+{
+	return addressType_;
+}
+
+void DescribeLoadBalancersRequest::setAddressType(const std::string& addressType)
+{
+	addressType_ = addressType;
+	setParameter("AddressType", addressType);
+}
+
+std::string DescribeLoadBalancersRequest::getFuzzy()const
+{
+	return fuzzy_;
+}
+
+void DescribeLoadBalancersRequest::setFuzzy(const std::string& fuzzy)
+{
+	fuzzy_ = fuzzy;
+	setParameter("Fuzzy", fuzzy);
+}
+
+std::string DescribeLoadBalancersRequest::getBusinessStatus()const
+{
+	return businessStatus_;
+}
+
+void DescribeLoadBalancersRequest::setBusinessStatus(const std::string& businessStatus)
+{
+	businessStatus_ = businessStatus;
+	setParameter("BusinessStatus", businessStatus);
+}
+
+std::string DescribeLoadBalancersRequest::getAddress()const
+{
+	return address_;
+}
+
+void DescribeLoadBalancersRequest::setAddress(const std::string& address)
+{
+	address_ = address;
+	setParameter("Address", address);
+}
+
+std::string DescribeLoadBalancersRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeLoadBalancersRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeLoadBalancersRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeLoadBalancersRequest::getLoadBalancerStatus()const
+{
+	return loadBalancerStatus_;
+}
+
+void DescribeLoadBalancersRequest::setLoadBalancerStatus(const std::string& loadBalancerStatus)
+{
+	loadBalancerStatus_ = loadBalancerStatus;
+	setParameter("LoadBalancerStatus", loadBalancerStatus);
+}
+
 std::string DescribeLoadBalancersRequest::getVpcId()const
 {
 	return vpcId_;

slb/src/model/DescribeLoadBalancersResult.cc

@@ -79,14 +79,20 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
 			loadBalancersObject.resourceGroupId = valueLoadBalancersLoadBalancer["ResourceGroupId"].asString();
 		if(!valueLoadBalancersLoadBalancer["AddressIPVersion"].isNull())
 			loadBalancersObject.addressIPVersion = valueLoadBalancersLoadBalancer["AddressIPVersion"].asString();
-		auto allTagsNode = allLoadBalancersNode["Tags"]["Tag"];
-		for (auto allLoadBalancersNodeTagsTag : allTagsNode)
+		if(!valueLoadBalancersLoadBalancer["BusinessStatus"].isNull())
+			loadBalancersObject.businessStatus = valueLoadBalancersLoadBalancer["BusinessStatus"].asString();
+		if(!valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].isNull())
+			loadBalancersObject.modificationProtectionStatus = valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].asString();
+		if(!valueLoadBalancersLoadBalancer["ModificationProtectionReason"].isNull())
+			loadBalancersObject.modificationProtectionReason = valueLoadBalancersLoadBalancer["ModificationProtectionReason"].asString();
+		auto allTagsNode = valueLoadBalancersLoadBalancer["Tags"]["Tag"];
+		for (auto valueLoadBalancersLoadBalancerTagsTag : allTagsNode)
 		{
 			LoadBalancer::Tag tagsObject;
-			if(!allLoadBalancersNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allLoadBalancersNodeTagsTag["TagKey"].asString();
-			if(!allLoadBalancersNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allLoadBalancersNodeTagsTag["TagValue"].asString();
+			if(!valueLoadBalancersLoadBalancerTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueLoadBalancersLoadBalancerTagsTag["TagKey"].asString();
+			if(!valueLoadBalancersLoadBalancerTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueLoadBalancersLoadBalancerTagsTag["TagValue"].asString();
 			loadBalancersObject.tags.push_back(tagsObject);
 		}
 		loadBalancers_.push_back(loadBalancersObject);

slb/src/model/DescribeMasterSlaveVServerGroupAttributeRequest.cc

@@ -1,126 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h>
-
-using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupAttributeRequest;
-
-DescribeMasterSlaveVServerGroupAttributeRequest::DescribeMasterSlaveVServerGroupAttributeRequest() :
-	RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroupAttribute")
-{}
-
-DescribeMasterSlaveVServerGroupAttributeRequest::~DescribeMasterSlaveVServerGroupAttributeRequest()
-{}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccess_key_id()const
-{
-	return access_key_id_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setAccess_key_id(const std::string& access_key_id)
-{
-	access_key_id_ = access_key_id;
-	setCoreParameter("Access_key_id", access_key_id);
-}
-
-long DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setCoreParameter("RegionId", regionId);
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getMasterSlaveVServerGroupId()const
-{
-	return masterSlaveVServerGroupId_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId)
-{
-	masterSlaveVServerGroupId_ = masterSlaveVServerGroupId;
-	setCoreParameter("MasterSlaveVServerGroupId", masterSlaveVServerGroupId);
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
-}
-
-long DescribeMasterSlaveVServerGroupAttributeRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeRequest::getTags()const
-{
-	return tags_;
-}
-
-void DescribeMasterSlaveVServerGroupAttributeRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setCoreParameter("Tags", tags);
-}
-

slb/src/model/DescribeMasterSlaveVServerGroupAttributeResult.cc

@@ -1,87 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Slb;
-using namespace AlibabaCloud::Slb::Model;
-
-DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult() :
-	ServiceResult()
-{}
-
-DescribeMasterSlaveVServerGroupAttributeResult::DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeMasterSlaveVServerGroupAttributeResult::~DescribeMasterSlaveVServerGroupAttributeResult()
-{}
-
-void DescribeMasterSlaveVServerGroupAttributeResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveBackendServersNode = value["MasterSlaveBackendServers"]["MasterSlaveBackendServer"];
-	for (auto valueMasterSlaveBackendServersMasterSlaveBackendServer : allMasterSlaveBackendServersNode)
-	{
-		MasterSlaveBackendServer masterSlaveBackendServersObject;
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].isNull())
-			masterSlaveBackendServersObject.serverId = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerId"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].isNull())
-			masterSlaveBackendServersObject.port = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Port"].asString());
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].isNull())
-			masterSlaveBackendServersObject.weight = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["Weight"].asString());
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].isNull())
-			masterSlaveBackendServersObject.isBackup = std::stoi(valueMasterSlaveBackendServersMasterSlaveBackendServer["IsBackup"].asString());
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].isNull())
-			masterSlaveBackendServersObject.type = valueMasterSlaveBackendServersMasterSlaveBackendServer["Type"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].isNull())
-			masterSlaveBackendServersObject.serverIp = valueMasterSlaveBackendServersMasterSlaveBackendServer["ServerIp"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].isNull())
-			masterSlaveBackendServersObject.eniHost = valueMasterSlaveBackendServersMasterSlaveBackendServer["EniHost"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].isNull())
-			masterSlaveBackendServersObject.vpcId = valueMasterSlaveBackendServersMasterSlaveBackendServer["VpcId"].asString();
-		if(!valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].isNull())
-			masterSlaveBackendServersObject.description = valueMasterSlaveBackendServersMasterSlaveBackendServer["Description"].asString();
-		masterSlaveBackendServers_.push_back(masterSlaveBackendServersObject);
-	}
-	if(!value["MasterSlaveVServerGroupId"].isNull())
-		masterSlaveVServerGroupId_ = value["MasterSlaveVServerGroupId"].asString();
-	if(!value["MasterSlaveVServerGroupName"].isNull())
-		masterSlaveVServerGroupName_ = value["MasterSlaveVServerGroupName"].asString();
-
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupId()const
-{
-	return masterSlaveVServerGroupId_;
-}
-
-std::vector<DescribeMasterSlaveVServerGroupAttributeResult::MasterSlaveBackendServer> DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveBackendServers()const
-{
-	return masterSlaveBackendServers_;
-}
-
-std::string DescribeMasterSlaveVServerGroupAttributeResult::getMasterSlaveVServerGroupName()const
-{
-	return masterSlaveVServerGroupName_;
-}
-

slb/src/model/DescribeMasterSlaveVServerGroupsRequest.cc

@@ -1,126 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DescribeMasterSlaveVServerGroupsRequest.h>
-
-using AlibabaCloud::Slb::Model::DescribeMasterSlaveVServerGroupsRequest;
-
-DescribeMasterSlaveVServerGroupsRequest::DescribeMasterSlaveVServerGroupsRequest() :
-	RpcServiceRequest("slb", "2014-05-15", "DescribeMasterSlaveVServerGroups")
-{}
-
-DescribeMasterSlaveVServerGroupsRequest::~DescribeMasterSlaveVServerGroupsRequest()
-{}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getAccess_key_id()const
-{
-	return access_key_id_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setAccess_key_id(const std::string& access_key_id)
-{
-	access_key_id_ = access_key_id;
-	setCoreParameter("Access_key_id", access_key_id);
-}
-
-long DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setCoreParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
-}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
-}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setCoreParameter("RegionId", regionId);
-}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setCoreParameter("ResourceOwnerAccount", resourceOwnerAccount);
-}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
-}
-
-long DescribeMasterSlaveVServerGroupsRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
-}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getTags()const
-{
-	return tags_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setTags(const std::string& tags)
-{
-	tags_ = tags;
-	setCoreParameter("Tags", tags);
-}
-
-std::string DescribeMasterSlaveVServerGroupsRequest::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-void DescribeMasterSlaveVServerGroupsRequest::setLoadBalancerId(const std::string& loadBalancerId)
-{
-	loadBalancerId_ = loadBalancerId;
-	setCoreParameter("LoadBalancerId", loadBalancerId);
-}
-

slb/src/model/DescribeMasterSlaveVServerGroupsResult.cc

@@ -1,59 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/DescribeMasterSlaveVServerGroupsResult.h>
-#include <json/json.h>
-
-using namespace AlibabaCloud::Slb;
-using namespace AlibabaCloud::Slb::Model;
-
-DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult() :
-	ServiceResult()
-{}
-
-DescribeMasterSlaveVServerGroupsResult::DescribeMasterSlaveVServerGroupsResult(const std::string &payload) :
-	ServiceResult()
-{
-	parse(payload);
-}
-
-DescribeMasterSlaveVServerGroupsResult::~DescribeMasterSlaveVServerGroupsResult()
-{}
-
-void DescribeMasterSlaveVServerGroupsResult::parse(const std::string &payload)
-{
-	Json::Reader reader;
-	Json::Value value;
-	reader.parse(payload, value);
-	setRequestId(value["RequestId"].asString());
-	auto allMasterSlaveVServerGroupsNode = value["MasterSlaveVServerGroups"]["MasterSlaveVServerGroup"];
-	for (auto valueMasterSlaveVServerGroupsMasterSlaveVServerGroup : allMasterSlaveVServerGroupsNode)
-	{
-		MasterSlaveVServerGroup masterSlaveVServerGroupsObject;
-		if(!valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupId"].isNull())
-			masterSlaveVServerGroupsObject.masterSlaveVServerGroupId = valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupId"].asString();
-		if(!valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupName"].isNull())
-			masterSlaveVServerGroupsObject.masterSlaveVServerGroupName = valueMasterSlaveVServerGroupsMasterSlaveVServerGroup["MasterSlaveVServerGroupName"].asString();
-		masterSlaveVServerGroups_.push_back(masterSlaveVServerGroupsObject);
-	}
-
-}
-
-std::vector<DescribeMasterSlaveVServerGroupsResult::MasterSlaveVServerGroup> DescribeMasterSlaveVServerGroupsResult::getMasterSlaveVServerGroups()const
-{
-	return masterSlaveVServerGroups_;
-}
-

slb/src/model/DescribeServerCertificatesResult.cc

@@ -71,14 +71,20 @@ void DescribeServerCertificatesResult::parse(const std::string &payload)
 			serverCertificatesObject.expireTimeStamp = std::stol(valueServerCertificatesServerCertificate["ExpireTimeStamp"].asString());
 		if(!valueServerCertificatesServerCertificate["CommonName"].isNull())
 			serverCertificatesObject.commonName = valueServerCertificatesServerCertificate["CommonName"].asString();
-		auto allTagsNode = allServerCertificatesNode["Tags"]["Tag"];
-		for (auto allServerCertificatesNodeTagsTag : allTagsNode)
+		if(!valueServerCertificatesServerCertificate["EncryptionAlgorithm"].isNull())
+			serverCertificatesObject.encryptionAlgorithm = valueServerCertificatesServerCertificate["EncryptionAlgorithm"].asString();
+		if(!valueServerCertificatesServerCertificate["EncryptionKeyLength"].isNull())
+			serverCertificatesObject.encryptionKeyLength = std::stoi(valueServerCertificatesServerCertificate["EncryptionKeyLength"].asString());
+		if(!valueServerCertificatesServerCertificate["StandardType"].isNull())
+			serverCertificatesObject.standardType = valueServerCertificatesServerCertificate["StandardType"].asString();
+		auto allTagsNode = valueServerCertificatesServerCertificate["Tags"]["Tag"];
+		for (auto valueServerCertificatesServerCertificateTagsTag : allTagsNode)
 		{
 			ServerCertificate::Tag tagsObject;
-			if(!allServerCertificatesNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allServerCertificatesNodeTagsTag["TagKey"].asString();
-			if(!allServerCertificatesNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allServerCertificatesNodeTagsTag["TagValue"].asString();
+			if(!valueServerCertificatesServerCertificateTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueServerCertificatesServerCertificateTagsTag["TagKey"].asString();
+			if(!valueServerCertificatesServerCertificateTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueServerCertificatesServerCertificateTagsTag["TagValue"].asString();
 			serverCertificatesObject.tags.push_back(tagsObject);
 		}
 		auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];

slb/src/model/DescribeZonesResult.cc

@@ -47,14 +47,14 @@ void DescribeZonesResult::parse(const std::string &payload)
 			zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
 		if(!valueZonesZone["LocalName"].isNull())
 			zonesObject.localName = valueZonesZone["LocalName"].asString();
-		auto allSlaveZonesNode = allZonesNode["SlaveZones"]["SlaveZone"];
-		for (auto allZonesNodeSlaveZonesSlaveZone : allSlaveZonesNode)
+		auto allSlaveZonesNode = valueZonesZone["SlaveZones"]["SlaveZone"];
+		for (auto valueZonesZoneSlaveZonesSlaveZone : allSlaveZonesNode)
 		{
 			Zone::SlaveZone slaveZonesObject;
-			if(!allZonesNodeSlaveZonesSlaveZone["ZoneId"].isNull())
-				slaveZonesObject.zoneId = allZonesNodeSlaveZonesSlaveZone["ZoneId"].asString();
-			if(!allZonesNodeSlaveZonesSlaveZone["LocalName"].isNull())
-				slaveZonesObject.localName = allZonesNodeSlaveZonesSlaveZone["LocalName"].asString();
+			if(!valueZonesZoneSlaveZonesSlaveZone["ZoneId"].isNull())
+				slaveZonesObject.zoneId = valueZonesZoneSlaveZonesSlaveZone["ZoneId"].asString();
+			if(!valueZonesZoneSlaveZonesSlaveZone["LocalName"].isNull())
+				slaveZonesObject.localName = valueZonesZoneSlaveZonesSlaveZone["LocalName"].asString();
 			zonesObject.slaveZones.push_back(slaveZonesObject);
 		}
 		zones_.push_back(zonesObject);

slb/src/model/ListTLSCipherPoliciesRequest.cc

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/slb/model/ListTLSCipherPoliciesRequest.h>
+
+using AlibabaCloud::Slb::Model::ListTLSCipherPoliciesRequest;
+
+ListTLSCipherPoliciesRequest::ListTLSCipherPoliciesRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "ListTLSCipherPolicies")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListTLSCipherPoliciesRequest::~ListTLSCipherPoliciesRequest()
+{}
+
+std::string ListTLSCipherPoliciesRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void ListTLSCipherPoliciesRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long ListTLSCipherPoliciesRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ListTLSCipherPoliciesRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+bool ListTLSCipherPoliciesRequest::getIncludeListener()const
+{
+	return includeListener_;
+}
+
+void ListTLSCipherPoliciesRequest::setIncludeListener(bool includeListener)
+{
+	includeListener_ = includeListener;
+	setParameter("IncludeListener", includeListener ? "true" : "false");
+}
+
+std::string ListTLSCipherPoliciesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ListTLSCipherPoliciesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ListTLSCipherPoliciesRequest::getTLSCipherPolicyId()const
+{
+	return tLSCipherPolicyId_;
+}
+
+void ListTLSCipherPoliciesRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
+{
+	tLSCipherPolicyId_ = tLSCipherPolicyId;
+	setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
+}
+
+std::string ListTLSCipherPoliciesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ListTLSCipherPoliciesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ListTLSCipherPoliciesRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void ListTLSCipherPoliciesRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string ListTLSCipherPoliciesRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ListTLSCipherPoliciesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ListTLSCipherPoliciesRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ListTLSCipherPoliciesRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ListTLSCipherPoliciesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ListTLSCipherPoliciesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ListTLSCipherPoliciesRequest::getName()const
+{
+	return name_;
+}
+
+void ListTLSCipherPoliciesRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+int ListTLSCipherPoliciesRequest::getMaxItems()const
+{
+	return maxItems_;
+}
+
+void ListTLSCipherPoliciesRequest::setMaxItems(int maxItems)
+{
+	maxItems_ = maxItems;
+	setParameter("MaxItems", std::to_string(maxItems));
+}
+

slb/src/model/ListTLSCipherPoliciesResult.cc

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/slb/model/ListTLSCipherPoliciesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Slb;
+using namespace AlibabaCloud::Slb::Model;
+
+ListTLSCipherPoliciesResult::ListTLSCipherPoliciesResult() :
+	ServiceResult()
+{}
+
+ListTLSCipherPoliciesResult::ListTLSCipherPoliciesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTLSCipherPoliciesResult::~ListTLSCipherPoliciesResult()
+{}
+
+void ListTLSCipherPoliciesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTLSCipherPoliciesNode = value["TLSCipherPolicies"]["TLSCipherPolicy"];
+	for (auto valueTLSCipherPoliciesTLSCipherPolicy : allTLSCipherPoliciesNode)
+	{
+		TLSCipherPolicy tLSCipherPoliciesObject;
+		if(!valueTLSCipherPoliciesTLSCipherPolicy["CreateTime"].isNull())
+			tLSCipherPoliciesObject.createTime = std::stol(valueTLSCipherPoliciesTLSCipherPolicy["CreateTime"].asString());
+		if(!valueTLSCipherPoliciesTLSCipherPolicy["InstanceId"].isNull())
+			tLSCipherPoliciesObject.instanceId = valueTLSCipherPoliciesTLSCipherPolicy["InstanceId"].asString();
+		if(!valueTLSCipherPoliciesTLSCipherPolicy["Name"].isNull())
+			tLSCipherPoliciesObject.name = valueTLSCipherPoliciesTLSCipherPolicy["Name"].asString();
+		if(!valueTLSCipherPoliciesTLSCipherPolicy["Status"].isNull())
+			tLSCipherPoliciesObject.status = valueTLSCipherPoliciesTLSCipherPolicy["Status"].asString();
+		auto allRelateListenersNode = valueTLSCipherPoliciesTLSCipherPolicy["RelateListeners"]["RelateListener"];
+		for (auto valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener : allRelateListenersNode)
+		{
+			TLSCipherPolicy::RelateListener relateListenersObject;
+			if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["LoadBalancerId"].isNull())
+				relateListenersObject.loadBalancerId = valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["LoadBalancerId"].asString();
+			if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Port"].isNull())
+				relateListenersObject.port = std::stoi(valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Port"].asString());
+			if(!valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Protocol"].isNull())
+				relateListenersObject.protocol = valueTLSCipherPoliciesTLSCipherPolicyRelateListenersRelateListener["Protocol"].asString();
+			tLSCipherPoliciesObject.relateListeners.push_back(relateListenersObject);
+		}
+		auto allTLSVersions = value["TLSVersions"]["TLSVersion"];
+		for (auto value : allTLSVersions)
+			tLSCipherPoliciesObject.tLSVersions.push_back(value.asString());
+		auto allCiphers = value["Ciphers"]["Cipher"];
+		for (auto value : allCiphers)
+			tLSCipherPoliciesObject.ciphers.push_back(value.asString());
+		tLSCipherPolicies_.push_back(tLSCipherPoliciesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["IsTruncated"].isNull())
+		isTruncated_ = value["IsTruncated"].asString() == "true";
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int ListTLSCipherPoliciesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string ListTLSCipherPoliciesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListTLSCipherPoliciesResult::TLSCipherPolicy> ListTLSCipherPoliciesResult::getTLSCipherPolicies()const
+{
+	return tLSCipherPolicies_;
+}
+
+bool ListTLSCipherPoliciesResult::getIsTruncated()const
+{
+	return isTruncated_;
+}
+

slb/src/model/SetDomainExtensionAttributeRequest.cc

@@ -49,6 +49,23 @@ void SetDomainExtensionAttributeRequest::setResourceOwnerId(long resourceOwnerId
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::vector<SetDomainExtensionAttributeRequest::ServerCertificate> SetDomainExtensionAttributeRequest::getServerCertificate()const
+{
+	return serverCertificate_;
+}
+
+void SetDomainExtensionAttributeRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
+{
+	serverCertificate_ = serverCertificate;
+	for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
+		auto serverCertificateObj = serverCertificate.at(dep1);
+		std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
+		setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
+		setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
+		setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
+	}
+}
+
 std::string SetDomainExtensionAttributeRequest::getRegionId()const
 {
 	return regionId_;
@@ -93,6 +110,19 @@ void SetDomainExtensionAttributeRequest::setOwnerAccount(const std::string& owne
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::vector<std::string> SetDomainExtensionAttributeRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void SetDomainExtensionAttributeRequest::setCertificateId(const std::vector<std::string>& certificateId)
+{
+	certificateId_ = certificateId;
+	for(int dep1 = 0; dep1!= certificateId.size(); dep1++) {
+		setParameter("CertificateId."+ std::to_string(dep1), certificateId.at(dep1));
+	}
+}
+
 long SetDomainExtensionAttributeRequest::getOwnerId()const
 {
 	return ownerId_;

slb/src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc

@@ -38,6 +38,23 @@ void SetLoadBalancerHTTPSListenerAttributeRequest::setResourceOwnerId(long resou
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::vector<SetLoadBalancerHTTPSListenerAttributeRequest::ServerCertificate> SetLoadBalancerHTTPSListenerAttributeRequest::getServerCertificate()const
+{
+	return serverCertificate_;
+}
+
+void SetLoadBalancerHTTPSListenerAttributeRequest::setServerCertificate(const std::vector<ServerCertificate>& serverCertificate)
+{
+	serverCertificate_ = serverCertificate;
+	for(int dep1 = 0; dep1!= serverCertificate.size(); dep1++) {
+		auto serverCertificateObj = serverCertificate.at(dep1);
+		std::string serverCertificateObjStr = "ServerCertificate." + std::to_string(dep1 + 1);
+		setParameter(serverCertificateObjStr + ".BindingType", serverCertificateObj.bindingType);
+		setParameter(serverCertificateObjStr + ".CertificateId", serverCertificateObj.certificateId);
+		setParameter(serverCertificateObjStr + ".StandardType", serverCertificateObj.standardType);
+	}
+}
+
 int SetLoadBalancerHTTPSListenerAttributeRequest::getHealthCheckTimeout()const
 {
 	return healthCheckTimeout_;

slb/src/model/SetLoadBalancerListenerAttributeExRequest.cc

@@ -1,89 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/slb/model/SetLoadBalancerListenerAttributeExRequest.h>
-
-using AlibabaCloud::Slb::Model::SetLoadBalancerListenerAttributeExRequest;
-
-SetLoadBalancerListenerAttributeExRequest::SetLoadBalancerListenerAttributeExRequest() :
-	RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerListenerAttributeEx")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-SetLoadBalancerListenerAttributeExRequest::~SetLoadBalancerListenerAttributeExRequest()
-{}
-
-int SetLoadBalancerListenerAttributeExRequest::getListenerPort()const
-{
-	return listenerPort_;
-}
-
-void SetLoadBalancerListenerAttributeExRequest::setListenerPort(int listenerPort)
-{
-	listenerPort_ = listenerPort;
-	setParameter("ListenerPort", std::to_string(listenerPort));
-}
-
-std::vector<SetLoadBalancerListenerAttributeExRequest::KvAttribute> SetLoadBalancerListenerAttributeExRequest::getKvAttribute()const
-{
-	return kvAttribute_;
-}
-
-void SetLoadBalancerListenerAttributeExRequest::setKvAttribute(const std::vector<KvAttribute>& kvAttribute)
-{
-	kvAttribute_ = kvAttribute;
-	for(int dep1 = 0; dep1!= kvAttribute.size(); dep1++) {
-		auto kvAttributeObj = kvAttribute.at(dep1);
-		std::string kvAttributeObjStr = "KvAttribute." + std::to_string(dep1 + 1);
-		setParameter(kvAttributeObjStr + ".Value", kvAttributeObj.value);
-		setParameter(kvAttributeObjStr + ".Key", kvAttributeObj.key);
-	}
-}
-
-std::string SetLoadBalancerListenerAttributeExRequest::getProtocol()const
-{
-	return protocol_;
-}
-
-void SetLoadBalancerListenerAttributeExRequest::setProtocol(const std::string& protocol)
-{
-	protocol_ = protocol;
-	setParameter("Protocol", protocol);
-}
-
-std::string SetLoadBalancerListenerAttributeExRequest::getLoadBalancerId()const
-{
-	return loadBalancerId_;
-}
-
-void SetLoadBalancerListenerAttributeExRequest::setLoadBalancerId(const std::string& loadBalancerId)
-{
-	loadBalancerId_ = loadBalancerId;
-	setParameter("LoadBalancerId", loadBalancerId);
-}
-
-std::string SetLoadBalancerListenerAttributeExRequest::getRegionId()const
-{
-	return regionId_;
-}
-
-void SetLoadBalancerListenerAttributeExRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
-}
-

slb/src/model/SetLoadBalancerModificationProtectionRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/slb/model/SetLoadBalancerModificationProtectionRequest.h>
+
+using AlibabaCloud::Slb::Model::SetLoadBalancerModificationProtectionRequest;
+
+SetLoadBalancerModificationProtectionRequest::SetLoadBalancerModificationProtectionRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "SetLoadBalancerModificationProtection")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetLoadBalancerModificationProtectionRequest::~SetLoadBalancerModificationProtectionRequest()
+{}
+
+std::string SetLoadBalancerModificationProtectionRequest::getModificationProtectionReason()const
+{
+	return modificationProtectionReason_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setModificationProtectionReason(const std::string& modificationProtectionReason)
+{
+	modificationProtectionReason_ = modificationProtectionReason;
+	setParameter("ModificationProtectionReason", modificationProtectionReason);
+}
+
+long SetLoadBalancerModificationProtectionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SetLoadBalancerModificationProtectionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string SetLoadBalancerModificationProtectionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SetLoadBalancerModificationProtectionRequest::getModificationProtectionStatus()const
+{
+	return modificationProtectionStatus_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setModificationProtectionStatus(const std::string& modificationProtectionStatus)
+{
+	modificationProtectionStatus_ = modificationProtectionStatus;
+	setParameter("ModificationProtectionStatus", modificationProtectionStatus);
+}
+
+std::string SetLoadBalancerModificationProtectionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long SetLoadBalancerModificationProtectionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetLoadBalancerModificationProtectionRequest::getLoadBalancerId()const
+{
+	return loadBalancerId_;
+}
+
+void SetLoadBalancerModificationProtectionRequest::setLoadBalancerId(const std::string& loadBalancerId)
+{
+	loadBalancerId_ = loadBalancerId;
+	setParameter("LoadBalancerId", loadBalancerId);
+}
+

slb/src/model/SetLoadBalancerListenerAttributeExResult.cc → slb/src/model/SetLoadBalancerModificationProtectionResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/slb/model/SetLoadBalancerListenerAttributeExResult.h>
+#include <alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h>
 #include <json/json.h>
 
 using namespace AlibabaCloud::Slb;
 using namespace AlibabaCloud::Slb::Model;
 
-SetLoadBalancerListenerAttributeExResult::SetLoadBalancerListenerAttributeExResult() :
+SetLoadBalancerModificationProtectionResult::SetLoadBalancerModificationProtectionResult() :
 	ServiceResult()
 {}
 
-SetLoadBalancerListenerAttributeExResult::SetLoadBalancerListenerAttributeExResult(const std::string &payload) :
+SetLoadBalancerModificationProtectionResult::SetLoadBalancerModificationProtectionResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-SetLoadBalancerListenerAttributeExResult::~SetLoadBalancerListenerAttributeExResult()
+SetLoadBalancerModificationProtectionResult::~SetLoadBalancerModificationProtectionResult()
 {}
 
-void SetLoadBalancerListenerAttributeExResult::parse(const std::string &payload)
+void SetLoadBalancerModificationProtectionResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

slb/src/model/SetTLSCipherPolicyAttributeRequest.cc

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/slb/model/SetTLSCipherPolicyAttributeRequest.h>
+
+using AlibabaCloud::Slb::Model::SetTLSCipherPolicyAttributeRequest;
+
+SetTLSCipherPolicyAttributeRequest::SetTLSCipherPolicyAttributeRequest() :
+	RpcServiceRequest("slb", "2014-05-15", "SetTLSCipherPolicyAttribute")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetTLSCipherPolicyAttributeRequest::~SetTLSCipherPolicyAttributeRequest()
+{}
+
+std::string SetTLSCipherPolicyAttributeRequest::getAccess_key_id()const
+{
+	return access_key_id_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setAccess_key_id(const std::string& access_key_id)
+{
+	access_key_id_ = access_key_id;
+	setParameter("Access_key_id", access_key_id);
+}
+
+long SetTLSCipherPolicyAttributeRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string SetTLSCipherPolicyAttributeRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string SetTLSCipherPolicyAttributeRequest::getTLSCipherPolicyId()const
+{
+	return tLSCipherPolicyId_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setTLSCipherPolicyId(const std::string& tLSCipherPolicyId)
+{
+	tLSCipherPolicyId_ = tLSCipherPolicyId;
+	setParameter("TLSCipherPolicyId", tLSCipherPolicyId);
+}
+
+std::string SetTLSCipherPolicyAttributeRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<std::string> SetTLSCipherPolicyAttributeRequest::getCiphers()const
+{
+	return ciphers_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setCiphers(const std::vector<std::string>& ciphers)
+{
+	ciphers_ = ciphers;
+	for(int dep1 = 0; dep1!= ciphers.size(); dep1++) {
+		setParameter("Ciphers."+ std::to_string(dep1), ciphers.at(dep1));
+	}
+}
+
+std::vector<std::string> SetTLSCipherPolicyAttributeRequest::getTLSVersions()const
+{
+	return tLSVersions_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setTLSVersions(const std::vector<std::string>& tLSVersions)
+{
+	tLSVersions_ = tLSVersions;
+	for(int dep1 = 0; dep1!= tLSVersions.size(); dep1++) {
+		setParameter("TLSVersions."+ std::to_string(dep1), tLSVersions.at(dep1));
+	}
+}
+
+std::string SetTLSCipherPolicyAttributeRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string SetTLSCipherPolicyAttributeRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long SetTLSCipherPolicyAttributeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetTLSCipherPolicyAttributeRequest::getName()const
+{
+	return name_;
+}
+
+void SetTLSCipherPolicyAttributeRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+

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

slb/src/model/UploadCACertificateRequest.cc

@@ -115,6 +115,17 @@ void UploadCACertificateRequest::setOwnerAccount(const std::string& ownerAccount
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string UploadCACertificateRequest::getStandardType()const
+{
+	return standardType_;
+}
+
+void UploadCACertificateRequest::setStandardType(const std::string& standardType)
+{
+	standardType_ = standardType;
+	setParameter("StandardType", standardType);
+}
+
 long UploadCACertificateRequest::getOwnerId()const
 {
 	return ownerId_;

slb/src/model/UploadServerCertificateRequest.cc

@@ -137,6 +137,17 @@ void UploadServerCertificateRequest::setOwnerAccount(const std::string& ownerAcc
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string UploadServerCertificateRequest::getStandardType()const
+{
+	return standardType_;
+}
+
+void UploadServerCertificateRequest::setStandardType(const std::string& standardType)
+{
+	standardType_ = standardType;
+	setParameter("StandardType", standardType);
+}
+
 long UploadServerCertificateRequest::getOwnerId()const
 {
 	return ownerId_;