Support latest openAPIs.

CHANGELOG

@@ -1,3 +1,6 @@
+2021-04-14 Version: 1.36.681
+- Support latest openAPIs.
+
 2021-04-14 Version: 1.36.680
 - Delete MultiMedia Post Scan API.
 

VERSION

@@ -1 +1 @@
-1.36.680
+1.36.681

slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h

@@ -47,14 +47,20 @@ namespace AlibabaCloud
 				void setHealthCheckURI(const std::string& healthCheckURI);
 				std::string getAclStatus()const;
 				void setAclStatus(const std::string& aclStatus);
+				bool getHealthCheckTcpFastCloseEnabled()const;
+				void setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled);
 				std::string getAclType()const;
 				void setAclType(const std::string& aclType);
 				int getEstablishedTimeout()const;
 				void setEstablishedTimeout(int establishedTimeout);
+				std::string getFailoverStrategy()const;
+				void setFailoverStrategy(const std::string& failoverStrategy);
 				int getPersistenceTimeout()const;
 				void setPersistenceTimeout(int persistenceTimeout);
 				std::string getVpcIds()const;
 				void setVpcIds(const std::string& vpcIds);
+				bool getMasterSlaveModeEnabled()const;
+				void setMasterSlaveModeEnabled(bool masterSlaveModeEnabled);
 				std::string getVServerGroupId()const;
 				void setVServerGroupId(const std::string& vServerGroupId);
 				std::string getAclId()const;
@@ -67,6 +73,8 @@ namespace AlibabaCloud
 				void setHealthCheckDomain(const std::string& healthCheckDomain);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				bool getProxyProtocolVpcIdEnabled()const;
+				void setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 				std::string getLoadBalancerId()const;
@@ -77,12 +85,20 @@ namespace AlibabaCloud
 				void setBackendServerPort(int backendServerPort);
 				int getHealthCheckInterval()const;
 				void setHealthCheckInterval(int healthCheckInterval);
+				int getFailoverThreshold()const;
+				void setFailoverThreshold(int failoverThreshold);
+				bool getProxyProtocolV2Enabled()const;
+				void setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled);
 				std::string getConnectionDrain()const;
 				void setConnectionDrain(const std::string& connectionDrain);
+				std::string getHealthCheckSwitch()const;
+				void setHealthCheckSwitch(const std::string& healthCheckSwitch);
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
 				int getHealthCheckConnectTimeout()const;
 				void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
+				std::string getSlaveServerGroupId()const;
+				void setSlaveServerGroupId(const std::string& slaveServerGroupId);
 				std::string getDescription()const;
 				void setDescription(const std::string& description);
 				int getUnhealthyThreshold()const;
@@ -95,6 +111,8 @@ namespace AlibabaCloud
 				void setMaxConnection(int maxConnection);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getMasterServerGroupId()const;
+				void setMasterServerGroupId(const std::string& masterServerGroupId);
 				int getListenerPort()const;
 				void setListenerPort(int listenerPort);
 				std::string getHealthCheckType()const;
@@ -116,30 +134,39 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string healthCheckURI_;
 				std::string aclStatus_;
+				bool healthCheckTcpFastCloseEnabled_;
 				std::string aclType_;
 				int establishedTimeout_;
+				std::string failoverStrategy_;
 				int persistenceTimeout_;
 				std::string vpcIds_;
+				bool masterSlaveModeEnabled_;
 				std::string vServerGroupId_;
 				std::string aclId_;
 				std::vector<PortRange> portRange_;
 				std::string healthCheckMethod_;
 				std::string healthCheckDomain_;
 				long ownerId_;
+				bool proxyProtocolVpcIdEnabled_;
 				std::string tags_;
 				std::string loadBalancerId_;
 				std::string masterSlaveServerGroupId_;
 				int backendServerPort_;
 				int healthCheckInterval_;
+				int failoverThreshold_;
+				bool proxyProtocolV2Enabled_;
 				std::string connectionDrain_;
+				std::string healthCheckSwitch_;
 				std::string access_key_id_;
 				int healthCheckConnectTimeout_;
+				std::string slaveServerGroupId_;
 				std::string description_;
 				int unhealthyThreshold_;
 				int healthyThreshold_;
 				std::string scheduler_;
 				int maxConnection_;
 				std::string regionId_;
+				std::string masterServerGroupId_;
 				int listenerPort_;
 				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;

slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h

@@ -43,22 +43,34 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getHealthCheckURI()const;
+				void setHealthCheckURI(const std::string& healthCheckURI);
 				std::string getAclStatus()const;
 				void setAclStatus(const std::string& aclStatus);
 				std::string getAclType()const;
 				void setAclType(const std::string& aclType);
+				std::string getFailoverStrategy()const;
+				void setFailoverStrategy(const std::string& failoverStrategy);
 				int getPersistenceTimeout()const;
 				void setPersistenceTimeout(int persistenceTimeout);
 				std::string getVpcIds()const;
 				void setVpcIds(const std::string& vpcIds);
+				bool getMasterSlaveModeEnabled()const;
+				void setMasterSlaveModeEnabled(bool masterSlaveModeEnabled);
 				std::string getVServerGroupId()const;
 				void setVServerGroupId(const std::string& vServerGroupId);
 				std::string getAclId()const;
 				void setAclId(const std::string& aclId);
 				std::vector<PortRange> getPortRange()const;
 				void setPortRange(const std::vector<PortRange>& portRange);
+				std::string getHealthCheckMethod()const;
+				void setHealthCheckMethod(const std::string& healthCheckMethod);
+				std::string getHealthCheckDomain()const;
+				void setHealthCheckDomain(const std::string& healthCheckDomain);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				bool getProxyProtocolVpcIdEnabled()const;
+				void setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 				std::string getLoadBalancerId()const;
@@ -73,12 +85,22 @@ namespace AlibabaCloud
 				void setHealthCheckInterval(int healthCheckInterval);
 				std::string getHealthCheckExp()const;
 				void setHealthCheckExp(const std::string& healthCheckExp);
+				int getFailoverThreshold()const;
+				void setFailoverThreshold(int failoverThreshold);
+				bool getProxyProtocolV2Enabled()const;
+				void setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled);
 				std::string getConnectionDrain()const;
 				void setConnectionDrain(const std::string& connectionDrain);
+				std::string getHealthCheckSwitch()const;
+				void setHealthCheckSwitch(const std::string& healthCheckSwitch);
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
 				int getHealthCheckConnectTimeout()const;
 				void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
+				std::string getSlaveServerGroupId()const;
+				void setSlaveServerGroupId(const std::string& slaveServerGroupId);
+				std::string getQuicVersion()const;
+				void setQuicVersion(const std::string& quicVersion);
 				std::string getDescription()const;
 				void setDescription(const std::string& description);
 				int getUnhealthyThreshold()const;
@@ -91,8 +113,12 @@ namespace AlibabaCloud
 				void setMaxConnection(int maxConnection);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getMasterServerGroupId()const;
+				void setMasterServerGroupId(const std::string& masterServerGroupId);
 				int getListenerPort()const;
 				void setListenerPort(int listenerPort);
+				std::string getHealthCheckType()const;
+				void setHealthCheckType(const std::string& healthCheckType);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				int getBandwidth()const;
@@ -103,17 +129,25 @@ namespace AlibabaCloud
 				void setConnectionDrainTimeout(int connectionDrainTimeout);
 				int getHealthCheckConnectPort()const;
 				void setHealthCheckConnectPort(int healthCheckConnectPort);
+				std::string getHealthCheckHttpCode()const;
+				void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
 
             private:
 				long resourceOwnerId_;
+				std::string healthCheckURI_;
 				std::string aclStatus_;
 				std::string aclType_;
+				std::string failoverStrategy_;
 				int persistenceTimeout_;
 				std::string vpcIds_;
+				bool masterSlaveModeEnabled_;
 				std::string vServerGroupId_;
 				std::string aclId_;
 				std::vector<PortRange> portRange_;
+				std::string healthCheckMethod_;
+				std::string healthCheckDomain_;
 				long ownerId_;
+				bool proxyProtocolVpcIdEnabled_;
 				std::string tags_;
 				std::string loadBalancerId_;
 				std::string masterSlaveServerGroupId_;
@@ -121,21 +155,29 @@ namespace AlibabaCloud
 				int backendServerPort_;
 				int healthCheckInterval_;
 				std::string healthCheckExp_;
+				int failoverThreshold_;
+				bool proxyProtocolV2Enabled_;
 				std::string connectionDrain_;
+				std::string healthCheckSwitch_;
 				std::string access_key_id_;
 				int healthCheckConnectTimeout_;
+				std::string slaveServerGroupId_;
+				std::string quicVersion_;
 				std::string description_;
 				int unhealthyThreshold_;
 				int healthyThreshold_;
 				std::string scheduler_;
 				int maxConnection_;
 				std::string regionId_;
+				std::string masterServerGroupId_;
 				int listenerPort_;
+				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;
 				int bandwidth_;
 				std::string ownerAccount_;
 				int connectionDrainTimeout_;
 				int healthCheckConnectPort_;
+				std::string healthCheckHttpCode_;
 
 			};
 		}

slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct PortRange
 				{
-					int startPort;
 					int endPort;
+					int startPort;
 				};
 
 
@@ -44,19 +44,27 @@ namespace AlibabaCloud
 				~DescribeLoadBalancerTCPListenerAttributeResult();
 				int getMaxConnection()const;
 				std::string getVServerGroupId()const;
-				std::string getSynProxy()const;
+				bool getProxyProtocolVpcIdEnabled()const;
 				std::string getDescription()const;
+				std::string getSynProxy()const;
+				int getFailoverThreshold()const;
+				bool getProxyProtocolV2Enabled()const;
 				int getUnhealthyThreshold()const;
-				std::string getScheduler()const;
 				std::string getHealthCheckURI()const;
+				std::string getScheduler()const;
 				std::string getHealthCheck()const;
+				std::string getWorkingServerGroupId()const;
 				int getBackendServerPort()const;
+				bool getMasterSlaveModeEnabled()const;
+				bool getHealthCheckTcpFastCloseEnabled()const;
 				int getConnectionDrainTimeout()const;
 				int getPersistenceTimeout()const;
 				int getHealthCheckConnectPort()const;
+				std::string getMasterServerGroupId()const;
 				std::string getHealthCheckMethod()const;
 				int getBandwidth()const;
 				std::string getHealthCheckHttpCode()const;
+				std::string getSlaveServerGroupId()const;
 				int getEstablishedTimeout()const;
 				std::string getStatus()const;
 				int getListenerPort()const;
@@ -67,6 +75,7 @@ namespace AlibabaCloud
 				std::string getConnectionDrain()const;
 				std::string getAclStatus()const;
 				std::string getVpcIds()const;
+				std::string getFailoverStrategy()const;
 				int getHealthyThreshold()const;
 				std::string getHealthCheckDomain()const;
 				std::string getMasterSlaveServerGroupId()const;
@@ -79,19 +88,27 @@ namespace AlibabaCloud
 			private:
 				int maxConnection_;
 				std::string vServerGroupId_;
-				std::string synProxy_;
+				bool proxyProtocolVpcIdEnabled_;
 				std::string description_;
+				std::string synProxy_;
+				int failoverThreshold_;
+				bool proxyProtocolV2Enabled_;
 				int unhealthyThreshold_;
-				std::string scheduler_;
 				std::string healthCheckURI_;
+				std::string scheduler_;
 				std::string healthCheck_;
+				std::string workingServerGroupId_;
 				int backendServerPort_;
+				bool masterSlaveModeEnabled_;
+				bool healthCheckTcpFastCloseEnabled_;
 				int connectionDrainTimeout_;
 				int persistenceTimeout_;
 				int healthCheckConnectPort_;
+				std::string masterServerGroupId_;
 				std::string healthCheckMethod_;
 				int bandwidth_;
 				std::string healthCheckHttpCode_;
+				std::string slaveServerGroupId_;
 				int establishedTimeout_;
 				std::string status_;
 				int listenerPort_;
@@ -102,6 +119,7 @@ namespace AlibabaCloud
 				std::string connectionDrain_;
 				std::string aclStatus_;
 				std::string vpcIds_;
+				std::string failoverStrategy_;
 				int healthyThreshold_;
 				std::string healthCheckDomain_;
 				std::string masterSlaveServerGroupId_;

slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct PortRange
 				{
-					int startPort;
 					int endPort;
+					int startPort;
 				};
 
 
@@ -44,15 +44,26 @@ namespace AlibabaCloud
 				~DescribeLoadBalancerUDPListenerAttributeResult();
 				int getMaxConnection()const;
 				std::string getVServerGroupId()const;
+				bool getProxyProtocolVpcIdEnabled()const;
 				std::string getDescription()const;
+				int getFailoverThreshold()const;
+				bool getProxyProtocolV2Enabled()const;
 				int getUnhealthyThreshold()const;
+				std::string getHealthCheckURI()const;
 				std::string getScheduler()const;
 				std::string getHealthCheck()const;
+				std::string getWorkingServerGroupId()const;
 				int getBackendServerPort()const;
+				bool getMasterSlaveModeEnabled()const;
 				int getConnectionDrainTimeout()const;
 				int getPersistenceTimeout()const;
 				int getHealthCheckConnectPort()const;
+				std::string getMasterServerGroupId()const;
+				std::string getHealthCheckMethod()const;
 				int getBandwidth()const;
+				std::string getQuicVersion()const;
+				std::string getHealthCheckHttpCode()const;
+				std::string getSlaveServerGroupId()const;
 				std::string getStatus()const;
 				int getListenerPort()const;
 				int getHealthCheckInterval()const;
@@ -60,29 +71,44 @@ namespace AlibabaCloud
 				std::string getAclId()const;
 				int getHealthCheckConnectTimeout()const;
 				std::string getConnectionDrain()const;
-				std::string getHealthCheckReq()const;
+				std::string getHealthCheckSwitch()const;
 				std::string getAclStatus()const;
+				std::string getHealthCheckReq()const;
 				std::string getVpcIds()const;
-				int getHealthyThreshold()const;
+				std::string getFailoverStrategy()const;
 				std::string getHealthCheckExp()const;
+				int getHealthyThreshold()const;
+				std::string getHealthCheckDomain()const;
 				std::string getMasterSlaveServerGroupId()const;
 				std::string getAclType()const;
 				std::vector<std::string> getAclIds()const;
+				std::string getHealthCheckType()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				int maxConnection_;
 				std::string vServerGroupId_;
+				bool proxyProtocolVpcIdEnabled_;
 				std::string description_;
+				int failoverThreshold_;
+				bool proxyProtocolV2Enabled_;
 				int unhealthyThreshold_;
+				std::string healthCheckURI_;
 				std::string scheduler_;
 				std::string healthCheck_;
+				std::string workingServerGroupId_;
 				int backendServerPort_;
+				bool masterSlaveModeEnabled_;
 				int connectionDrainTimeout_;
 				int persistenceTimeout_;
 				int healthCheckConnectPort_;
+				std::string masterServerGroupId_;
+				std::string healthCheckMethod_;
 				int bandwidth_;
+				std::string quicVersion_;
+				std::string healthCheckHttpCode_;
+				std::string slaveServerGroupId_;
 				std::string status_;
 				int listenerPort_;
 				int healthCheckInterval_;
@@ -90,14 +116,18 @@ namespace AlibabaCloud
 				std::string aclId_;
 				int healthCheckConnectTimeout_;
 				std::string connectionDrain_;
-				std::string healthCheckReq_;
+				std::string healthCheckSwitch_;
 				std::string aclStatus_;
+				std::string healthCheckReq_;
 				std::string vpcIds_;
-				int healthyThreshold_;
+				std::string failoverStrategy_;
 				std::string healthCheckExp_;
+				int healthyThreshold_;
+				std::string healthCheckDomain_;
 				std::string masterSlaveServerGroupId_;
 				std::string aclType_;
 				std::vector<std::string> aclIds_;
+				std::string healthCheckType_;
 
 			};
 		}

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

@@ -91,6 +91,8 @@ namespace AlibabaCloud
 				void setAddress(const std::string& address);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				bool getFilterByTagOrName()const;
+				void setFilterByTagOrName(bool filterByTagOrName);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
 				std::string getLoadBalancerStatus()const;
@@ -126,6 +128,7 @@ namespace AlibabaCloud
 				std::string businessStatus_;
 				std::string address_;
 				std::string resourceOwnerAccount_;
+				bool filterByTagOrName_;
 				std::string ownerAccount_;
 				std::string loadBalancerStatus_;
 				std::string vpcId_;

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

@@ -41,25 +41,28 @@ namespace AlibabaCloud
 					};
 					std::string address;
 					std::string resourceGroupId;
-					std::string vSwitchId;
-					std::string createTime;
 					std::string addressIPVersion;
 					std::string loadBalancerId;
-					std::string payType;
-					std::string slaveZoneId;
 					std::string businessStatus;
 					std::string modificationProtectionStatus;
+					std::string loadBalancerSpec;
+					std::string networkType;
+					int bandwidth;
+					std::string modificationProtectionReason;
+					std::vector<LoadBalancer::Tag> tags;
+					std::string masterZoneId;
+					std::string vSwitchId;
+					std::string createTime;
+					std::string payType;
+					std::string slaveZoneId;
 					std::string internetChargeType;
 					std::string regionIdAlias;
+					std::string internetChargeTypeAlias;
 					std::string loadBalancerName;
 					std::string vpcId;
-					std::string networkType;
-					std::string modificationProtectionReason;
 					std::string regionId;
 					std::string addressType;
 					std::string loadBalancerStatus;
-					std::vector<LoadBalancer::Tag> tags;
-					std::string masterZoneId;
 					long createTimeStamp;
 				};
 

slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 					std::string description;
 					std::string vpcId;
 					std::string serverRegionId;
+					bool proxyProtocolV2Enabled;
 					int port;
 					std::string serverIp;
 					std::string vbrId;

slb/include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h

@@ -47,16 +47,22 @@ namespace AlibabaCloud
 				void setHealthCheckURI(const std::string& healthCheckURI);
 				std::string getAclStatus()const;
 				void setAclStatus(const std::string& aclStatus);
+				bool getHealthCheckTcpFastCloseEnabled()const;
+				void setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled);
 				std::string getAclType()const;
 				void setAclType(const std::string& aclType);
 				std::string getMasterSlaveServerGroup()const;
 				void setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup);
 				int getEstablishedTimeout()const;
 				void setEstablishedTimeout(int establishedTimeout);
+				std::string getFailoverStrategy()const;
+				void setFailoverStrategy(const std::string& failoverStrategy);
 				int getPersistenceTimeout()const;
 				void setPersistenceTimeout(int persistenceTimeout);
 				std::string getVpcIds()const;
 				void setVpcIds(const std::string& vpcIds);
+				bool getMasterSlaveModeEnabled()const;
+				void setMasterSlaveModeEnabled(bool masterSlaveModeEnabled);
 				std::string getVServerGroupId()const;
 				void setVServerGroupId(const std::string& vServerGroupId);
 				std::string getAclId()const;
@@ -71,6 +77,8 @@ namespace AlibabaCloud
 				void setSynProxy(const std::string& synProxy);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				bool getProxyProtocolVpcIdEnabled()const;
+				void setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 				std::string getLoadBalancerId()const;
@@ -79,12 +87,20 @@ namespace AlibabaCloud
 				void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
 				int getHealthCheckInterval()const;
 				void setHealthCheckInterval(int healthCheckInterval);
+				int getFailoverThreshold()const;
+				void setFailoverThreshold(int failoverThreshold);
+				bool getProxyProtocolV2Enabled()const;
+				void setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled);
 				std::string getConnectionDrain()const;
 				void setConnectionDrain(const std::string& connectionDrain);
+				std::string getHealthCheckSwitch()const;
+				void setHealthCheckSwitch(const std::string& healthCheckSwitch);
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
 				int getHealthCheckConnectTimeout()const;
 				void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
+				std::string getSlaveServerGroupId()const;
+				void setSlaveServerGroupId(const std::string& slaveServerGroupId);
 				std::string getDescription()const;
 				void setDescription(const std::string& description);
 				int getUnhealthyThreshold()const;
@@ -97,6 +113,8 @@ namespace AlibabaCloud
 				void setMaxConnection(int maxConnection);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getMasterServerGroupId()const;
+				void setMasterServerGroupId(const std::string& masterServerGroupId);
 				int getListenerPort()const;
 				void setListenerPort(int listenerPort);
 				std::string getHealthCheckType()const;
@@ -120,11 +138,14 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string healthCheckURI_;
 				std::string aclStatus_;
+				bool healthCheckTcpFastCloseEnabled_;
 				std::string aclType_;
 				std::string masterSlaveServerGroup_;
 				int establishedTimeout_;
+				std::string failoverStrategy_;
 				int persistenceTimeout_;
 				std::string vpcIds_;
+				bool masterSlaveModeEnabled_;
 				std::string vServerGroupId_;
 				std::string aclId_;
 				std::vector<PortRange> portRange_;
@@ -132,19 +153,25 @@ namespace AlibabaCloud
 				std::string healthCheckDomain_;
 				std::string synProxy_;
 				long ownerId_;
+				bool proxyProtocolVpcIdEnabled_;
 				std::string tags_;
 				std::string loadBalancerId_;
 				std::string masterSlaveServerGroupId_;
 				int healthCheckInterval_;
+				int failoverThreshold_;
+				bool proxyProtocolV2Enabled_;
 				std::string connectionDrain_;
+				std::string healthCheckSwitch_;
 				std::string access_key_id_;
 				int healthCheckConnectTimeout_;
+				std::string slaveServerGroupId_;
 				std::string description_;
 				int unhealthyThreshold_;
 				int healthyThreshold_;
 				std::string scheduler_;
 				int maxConnection_;
 				std::string regionId_;
+				std::string masterServerGroupId_;
 				int listenerPort_;
 				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;

slb/include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h

@@ -43,24 +43,36 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getHealthCheckURI()const;
+				void setHealthCheckURI(const std::string& healthCheckURI);
 				std::string getAclStatus()const;
 				void setAclStatus(const std::string& aclStatus);
 				std::string getAclType()const;
 				void setAclType(const std::string& aclType);
 				std::string getMasterSlaveServerGroup()const;
 				void setMasterSlaveServerGroup(const std::string& masterSlaveServerGroup);
+				std::string getFailoverStrategy()const;
+				void setFailoverStrategy(const std::string& failoverStrategy);
 				int getPersistenceTimeout()const;
 				void setPersistenceTimeout(int persistenceTimeout);
 				std::string getVpcIds()const;
 				void setVpcIds(const std::string& vpcIds);
+				bool getMasterSlaveModeEnabled()const;
+				void setMasterSlaveModeEnabled(bool masterSlaveModeEnabled);
 				std::string getVServerGroupId()const;
 				void setVServerGroupId(const std::string& vServerGroupId);
 				std::string getAclId()const;
 				void setAclId(const std::string& aclId);
 				std::vector<PortRange> getPortRange()const;
 				void setPortRange(const std::vector<PortRange>& portRange);
+				std::string getHealthCheckMethod()const;
+				void setHealthCheckMethod(const std::string& healthCheckMethod);
+				std::string getHealthCheckDomain()const;
+				void setHealthCheckDomain(const std::string& healthCheckDomain);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
+				bool getProxyProtocolVpcIdEnabled()const;
+				void setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 				std::string getLoadBalancerId()const;
@@ -73,12 +85,22 @@ namespace AlibabaCloud
 				void setHealthCheckInterval(int healthCheckInterval);
 				std::string getHealthCheckExp()const;
 				void setHealthCheckExp(const std::string& healthCheckExp);
+				int getFailoverThreshold()const;
+				void setFailoverThreshold(int failoverThreshold);
+				bool getProxyProtocolV2Enabled()const;
+				void setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled);
 				std::string getConnectionDrain()const;
 				void setConnectionDrain(const std::string& connectionDrain);
+				std::string getHealthCheckSwitch()const;
+				void setHealthCheckSwitch(const std::string& healthCheckSwitch);
 				std::string getAccess_key_id()const;
 				void setAccess_key_id(const std::string& access_key_id);
 				int getHealthCheckConnectTimeout()const;
 				void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
+				std::string getSlaveServerGroupId()const;
+				void setSlaveServerGroupId(const std::string& slaveServerGroupId);
+				std::string getQuicVersion()const;
+				void setQuicVersion(const std::string& quicVersion);
 				std::string getDescription()const;
 				void setDescription(const std::string& description);
 				int getUnhealthyThreshold()const;
@@ -91,8 +113,12 @@ namespace AlibabaCloud
 				void setMaxConnection(int maxConnection);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
+				std::string getMasterServerGroupId()const;
+				void setMasterServerGroupId(const std::string& masterServerGroupId);
 				int getListenerPort()const;
 				void setListenerPort(int listenerPort);
+				std::string getHealthCheckType()const;
+				void setHealthCheckType(const std::string& healthCheckType);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				int getBandwidth()const;
@@ -103,41 +129,57 @@ namespace AlibabaCloud
 				void setConnectionDrainTimeout(int connectionDrainTimeout);
 				int getHealthCheckConnectPort()const;
 				void setHealthCheckConnectPort(int healthCheckConnectPort);
+				std::string getHealthCheckHttpCode()const;
+				void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
 				std::string getVServerGroup()const;
 				void setVServerGroup(const std::string& vServerGroup);
 
             private:
 				long resourceOwnerId_;
+				std::string healthCheckURI_;
 				std::string aclStatus_;
 				std::string aclType_;
 				std::string masterSlaveServerGroup_;
+				std::string failoverStrategy_;
 				int persistenceTimeout_;
 				std::string vpcIds_;
+				bool masterSlaveModeEnabled_;
 				std::string vServerGroupId_;
 				std::string aclId_;
 				std::vector<PortRange> portRange_;
+				std::string healthCheckMethod_;
+				std::string healthCheckDomain_;
 				long ownerId_;
+				bool proxyProtocolVpcIdEnabled_;
 				std::string tags_;
 				std::string loadBalancerId_;
 				std::string masterSlaveServerGroupId_;
 				std::string healthCheckReq_;
 				int healthCheckInterval_;
 				std::string healthCheckExp_;
+				int failoverThreshold_;
+				bool proxyProtocolV2Enabled_;
 				std::string connectionDrain_;
+				std::string healthCheckSwitch_;
 				std::string access_key_id_;
 				int healthCheckConnectTimeout_;
+				std::string slaveServerGroupId_;
+				std::string quicVersion_;
 				std::string description_;
 				int unhealthyThreshold_;
 				int healthyThreshold_;
 				std::string scheduler_;
 				int maxConnection_;
 				std::string regionId_;
+				std::string masterServerGroupId_;
 				int listenerPort_;
+				std::string healthCheckType_;
 				std::string resourceOwnerAccount_;
 				int bandwidth_;
 				std::string ownerAccount_;
 				int connectionDrainTimeout_;
 				int healthCheckConnectPort_;
+				std::string healthCheckHttpCode_;
 				std::string vServerGroup_;
 
 			};

slb/src/model/CreateLoadBalancerTCPListenerRequest.cc

@@ -60,6 +60,17 @@ void CreateLoadBalancerTCPListenerRequest::setAclStatus(const std::string& aclSt
 	setParameter("AclStatus", aclStatus);
 }
 
+bool CreateLoadBalancerTCPListenerRequest::getHealthCheckTcpFastCloseEnabled()const
+{
+	return healthCheckTcpFastCloseEnabled_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled)
+{
+	healthCheckTcpFastCloseEnabled_ = healthCheckTcpFastCloseEnabled;
+	setParameter("HealthCheckTcpFastCloseEnabled", healthCheckTcpFastCloseEnabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getAclType()const
 {
 	return aclType_;
@@ -82,6 +93,17 @@ void CreateLoadBalancerTCPListenerRequest::setEstablishedTimeout(int established
 	setParameter("EstablishedTimeout", std::to_string(establishedTimeout));
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setFailoverStrategy(const std::string& failoverStrategy)
+{
+	failoverStrategy_ = failoverStrategy;
+	setParameter("FailoverStrategy", failoverStrategy);
+}
+
 int CreateLoadBalancerTCPListenerRequest::getPersistenceTimeout()const
 {
 	return persistenceTimeout_;
@@ -104,6 +126,17 @@ void CreateLoadBalancerTCPListenerRequest::setVpcIds(const std::string& vpcIds)
 	setParameter("VpcIds", vpcIds);
 }
 
+bool CreateLoadBalancerTCPListenerRequest::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setMasterSlaveModeEnabled(bool masterSlaveModeEnabled)
+{
+	masterSlaveModeEnabled_ = masterSlaveModeEnabled;
+	setParameter("MasterSlaveModeEnabled", masterSlaveModeEnabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -175,6 +208,17 @@ void CreateLoadBalancerTCPListenerRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+bool CreateLoadBalancerTCPListenerRequest::getProxyProtocolVpcIdEnabled()const
+{
+	return proxyProtocolVpcIdEnabled_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled)
+{
+	proxyProtocolVpcIdEnabled_ = proxyProtocolVpcIdEnabled;
+	setParameter("ProxyProtocolVpcIdEnabled", proxyProtocolVpcIdEnabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getTags()const
 {
 	return tags_;
@@ -230,6 +274,28 @@ void CreateLoadBalancerTCPListenerRequest::setHealthCheckInterval(int healthChec
 	setParameter("HealthCheckInterval", std::to_string(healthCheckInterval));
 }
 
+int CreateLoadBalancerTCPListenerRequest::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setFailoverThreshold(int failoverThreshold)
+{
+	failoverThreshold_ = failoverThreshold;
+	setParameter("FailoverThreshold", std::to_string(failoverThreshold));
+}
+
+bool CreateLoadBalancerTCPListenerRequest::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled)
+{
+	proxyProtocolV2Enabled_ = proxyProtocolV2Enabled;
+	setParameter("ProxyProtocolV2Enabled", proxyProtocolV2Enabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getConnectionDrain()const
 {
 	return connectionDrain_;
@@ -241,6 +307,17 @@ void CreateLoadBalancerTCPListenerRequest::setConnectionDrain(const std::string&
 	setParameter("ConnectionDrain", connectionDrain);
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getHealthCheckSwitch()const
+{
+	return healthCheckSwitch_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setHealthCheckSwitch(const std::string& healthCheckSwitch)
+{
+	healthCheckSwitch_ = healthCheckSwitch;
+	setParameter("HealthCheckSwitch", healthCheckSwitch);
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getAccess_key_id()const
 {
 	return access_key_id_;
@@ -263,6 +340,17 @@ void CreateLoadBalancerTCPListenerRequest::setHealthCheckConnectTimeout(int heal
 	setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout));
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setSlaveServerGroupId(const std::string& slaveServerGroupId)
+{
+	slaveServerGroupId_ = slaveServerGroupId;
+	setParameter("SlaveServerGroupId", slaveServerGroupId);
+}
+
 std::string CreateLoadBalancerTCPListenerRequest::getDescription()const
 {
 	return description_;
@@ -329,6 +417,17 @@ void CreateLoadBalancerTCPListenerRequest::setRegionId(const std::string& region
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateLoadBalancerTCPListenerRequest::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+void CreateLoadBalancerTCPListenerRequest::setMasterServerGroupId(const std::string& masterServerGroupId)
+{
+	masterServerGroupId_ = masterServerGroupId;
+	setParameter("MasterServerGroupId", masterServerGroupId);
+}
+
 int CreateLoadBalancerTCPListenerRequest::getListenerPort()const
 {
 	return listenerPort_;

slb/src/model/CreateLoadBalancerUDPListenerRequest.cc

@@ -38,6 +38,17 @@ void CreateLoadBalancerUDPListenerRequest::setResourceOwnerId(long resourceOwner
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckURI(const std::string& healthCheckURI)
+{
+	healthCheckURI_ = healthCheckURI;
+	setParameter("HealthCheckURI", healthCheckURI);
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getAclStatus()const
 {
 	return aclStatus_;
@@ -60,6 +71,17 @@ void CreateLoadBalancerUDPListenerRequest::setAclType(const std::string& aclType
 	setParameter("AclType", aclType);
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setFailoverStrategy(const std::string& failoverStrategy)
+{
+	failoverStrategy_ = failoverStrategy;
+	setParameter("FailoverStrategy", failoverStrategy);
+}
+
 int CreateLoadBalancerUDPListenerRequest::getPersistenceTimeout()const
 {
 	return persistenceTimeout_;
@@ -82,6 +104,17 @@ void CreateLoadBalancerUDPListenerRequest::setVpcIds(const std::string& vpcIds)
 	setParameter("VpcIds", vpcIds);
 }
 
+bool CreateLoadBalancerUDPListenerRequest::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMasterSlaveModeEnabled(bool masterSlaveModeEnabled)
+{
+	masterSlaveModeEnabled_ = masterSlaveModeEnabled;
+	setParameter("MasterSlaveModeEnabled", masterSlaveModeEnabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -120,6 +153,28 @@ void CreateLoadBalancerUDPListenerRequest::setPortRange(const std::vector<PortRa
 	}
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckMethod(const std::string& healthCheckMethod)
+{
+	healthCheckMethod_ = healthCheckMethod;
+	setParameter("HealthCheckMethod", healthCheckMethod);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckDomain(const std::string& healthCheckDomain)
+{
+	healthCheckDomain_ = healthCheckDomain;
+	setParameter("HealthCheckDomain", healthCheckDomain);
+}
+
 long CreateLoadBalancerUDPListenerRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -131,6 +186,17 @@ void CreateLoadBalancerUDPListenerRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+bool CreateLoadBalancerUDPListenerRequest::getProxyProtocolVpcIdEnabled()const
+{
+	return proxyProtocolVpcIdEnabled_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled)
+{
+	proxyProtocolVpcIdEnabled_ = proxyProtocolVpcIdEnabled;
+	setParameter("ProxyProtocolVpcIdEnabled", proxyProtocolVpcIdEnabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getTags()const
 {
 	return tags_;
@@ -208,6 +274,28 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckExp(const std::string&
 	setParameter("HealthCheckExp", healthCheckExp);
 }
 
+int CreateLoadBalancerUDPListenerRequest::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setFailoverThreshold(int failoverThreshold)
+{
+	failoverThreshold_ = failoverThreshold;
+	setParameter("FailoverThreshold", std::to_string(failoverThreshold));
+}
+
+bool CreateLoadBalancerUDPListenerRequest::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled)
+{
+	proxyProtocolV2Enabled_ = proxyProtocolV2Enabled;
+	setParameter("ProxyProtocolV2Enabled", proxyProtocolV2Enabled ? "true" : "false");
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getConnectionDrain()const
 {
 	return connectionDrain_;
@@ -219,6 +307,17 @@ void CreateLoadBalancerUDPListenerRequest::setConnectionDrain(const std::string&
 	setParameter("ConnectionDrain", connectionDrain);
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckSwitch()const
+{
+	return healthCheckSwitch_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckSwitch(const std::string& healthCheckSwitch)
+{
+	healthCheckSwitch_ = healthCheckSwitch;
+	setParameter("HealthCheckSwitch", healthCheckSwitch);
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getAccess_key_id()const
 {
 	return access_key_id_;
@@ -241,6 +340,28 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckConnectTimeout(int heal
 	setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout));
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setSlaveServerGroupId(const std::string& slaveServerGroupId)
+{
+	slaveServerGroupId_ = slaveServerGroupId;
+	setParameter("SlaveServerGroupId", slaveServerGroupId);
+}
+
+std::string CreateLoadBalancerUDPListenerRequest::getQuicVersion()const
+{
+	return quicVersion_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setQuicVersion(const std::string& quicVersion)
+{
+	quicVersion_ = quicVersion;
+	setParameter("QuicVersion", quicVersion);
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getDescription()const
 {
 	return description_;
@@ -307,6 +428,17 @@ void CreateLoadBalancerUDPListenerRequest::setRegionId(const std::string& region
 	setParameter("RegionId", regionId);
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setMasterServerGroupId(const std::string& masterServerGroupId)
+{
+	masterServerGroupId_ = masterServerGroupId;
+	setParameter("MasterServerGroupId", masterServerGroupId);
+}
+
 int CreateLoadBalancerUDPListenerRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -318,6 +450,17 @@ void CreateLoadBalancerUDPListenerRequest::setListenerPort(int listenerPort)
 	setParameter("ListenerPort", std::to_string(listenerPort));
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckType(const std::string& healthCheckType)
+{
+	healthCheckType_ = healthCheckType;
+	setParameter("HealthCheckType", healthCheckType);
+}
+
 std::string CreateLoadBalancerUDPListenerRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -373,3 +516,14 @@ void CreateLoadBalancerUDPListenerRequest::setHealthCheckConnectPort(int healthC
 	setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort));
 }
 
+std::string CreateLoadBalancerUDPListenerRequest::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+void CreateLoadBalancerUDPListenerRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode)
+{
+	healthCheckHttpCode_ = healthCheckHttpCode;
+	setParameter("HealthCheckHttpCode", healthCheckHttpCode);
+}
+

slb/src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc

@@ -43,73 +43,91 @@ void DescribeLoadBalancerTCPListenerAttributeResult::parse(const std::string &pa
 	for (auto valuePortRangesPortRange : allPortRangesNode)
 	{
 		PortRange portRangesObject;
-		if(!valuePortRangesPortRange["StartPort"].isNull())
-			portRangesObject.startPort = std::stoi(valuePortRangesPortRange["StartPort"].asString());
 		if(!valuePortRangesPortRange["EndPort"].isNull())
 			portRangesObject.endPort = std::stoi(valuePortRangesPortRange["EndPort"].asString());
+		if(!valuePortRangesPortRange["StartPort"].isNull())
+			portRangesObject.startPort = std::stoi(valuePortRangesPortRange["StartPort"].asString());
 		portRanges_.push_back(portRangesObject);
 	}
 	auto allAclIds = value["AclIds"]["AclId"];
 	for (const auto &item : allAclIds)
 		aclIds_.push_back(item.asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
 	if(!value["BackendServerPort"].isNull())
 		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
 	if(!value["Bandwidth"].isNull())
 		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["SynProxy"].isNull())
-		synProxy_ = value["SynProxy"].asString();
-	if(!value["PersistenceTimeout"].isNull())
-		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["ConnectionDrain"].isNull())
+		connectionDrain_ = value["ConnectionDrain"].asString();
+	if(!value["ConnectionDrainTimeout"].isNull())
+		connectionDrainTimeout_ = std::stoi(value["ConnectionDrainTimeout"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
 	if(!value["EstablishedTimeout"].isNull())
 		establishedTimeout_ = std::stoi(value["EstablishedTimeout"].asString());
+	if(!value["FailoverStrategy"].isNull())
+		failoverStrategy_ = value["FailoverStrategy"].asString();
+	if(!value["FailoverThreshold"].isNull())
+		failoverThreshold_ = std::stoi(value["FailoverThreshold"].asString());
 	if(!value["HealthCheck"].isNull())
 		healthCheck_ = value["HealthCheck"].asString();
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
-	if(!value["UnhealthyThreshold"].isNull())
-		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["HealthCheckConnectTimeout"].isNull())
-		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
 	if(!value["HealthCheckConnectPort"].isNull())
 		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
-	if(!value["HealthCheckInterval"].isNull())
-		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
-	if(!value["HealthCheckHttpCode"].isNull())
-		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["HealthCheckConnectTimeout"].isNull())
+		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
 	if(!value["HealthCheckDomain"].isNull())
 		healthCheckDomain_ = value["HealthCheckDomain"].asString();
-	if(!value["HealthCheckURI"].isNull())
-		healthCheckURI_ = value["HealthCheckURI"].asString();
-	if(!value["HealthCheckType"].isNull())
-		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
+	if(!value["HealthCheckInterval"].isNull())
+		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
 	if(!value["HealthCheckMethod"].isNull())
 		healthCheckMethod_ = value["HealthCheckMethod"].asString();
+	if(!value["HealthCheckTcpFastCloseEnabled"].isNull())
+		healthCheckTcpFastCloseEnabled_ = value["HealthCheckTcpFastCloseEnabled"].asString() == "true";
+	if(!value["HealthCheckType"].isNull())
+		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["MasterServerGroupId"].isNull())
+		masterServerGroupId_ = value["MasterServerGroupId"].asString();
+	if(!value["MasterSlaveModeEnabled"].isNull())
+		masterSlaveModeEnabled_ = value["MasterSlaveModeEnabled"].asString() == "true";
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
 	if(!value["MaxConnection"].isNull())
 		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["PersistenceTimeout"].isNull())
+		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["ProxyProtocolV2Enabled"].isNull())
+		proxyProtocolV2Enabled_ = value["ProxyProtocolV2Enabled"].asString() == "true";
+	if(!value["ProxyProtocolVpcIdEnabled"].isNull())
+		proxyProtocolVpcIdEnabled_ = value["ProxyProtocolVpcIdEnabled"].asString() == "true";
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["SlaveServerGroupId"].isNull())
+		slaveServerGroupId_ = value["SlaveServerGroupId"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["SynProxy"].isNull())
+		synProxy_ = value["SynProxy"].asString();
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
 	if(!value["VServerGroupId"].isNull())
 		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["MasterSlaveServerGroupId"].isNull())
-		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
-	if(!value["AclId"].isNull())
-		aclId_ = value["AclId"].asString();
-	if(!value["AclType"].isNull())
-		aclType_ = value["AclType"].asString();
-	if(!value["AclStatus"].isNull())
-		aclStatus_ = value["AclStatus"].asString();
 	if(!value["VpcIds"].isNull())
 		vpcIds_ = value["VpcIds"].asString();
-	if(!value["Description"].isNull())
-		description_ = value["Description"].asString();
-	if(!value["ConnectionDrain"].isNull())
-		connectionDrain_ = value["ConnectionDrain"].asString();
-	if(!value["ConnectionDrainTimeout"].isNull())
-		connectionDrainTimeout_ = std::stoi(value["ConnectionDrainTimeout"].asString());
+	if(!value["WorkingServerGroupId"].isNull())
+		workingServerGroupId_ = value["WorkingServerGroupId"].asString();
 
 }
 
@@ -123,9 +141,9 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getVServerGroupId()c
 	return vServerGroupId_;
 }
 
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const
+bool DescribeLoadBalancerTCPListenerAttributeResult::getProxyProtocolVpcIdEnabled()const
 {
-	return synProxy_;
+	return proxyProtocolVpcIdEnabled_;
 }
 
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getDescription()const
@@ -133,14 +151,24 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getDescription()cons
 	return description_;
 }
 
-int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getSynProxy()const
 {
-	return unhealthyThreshold_;
+	return synProxy_;
 }
 
-std::string DescribeLoadBalancerTCPListenerAttributeResult::getScheduler()const
+int DescribeLoadBalancerTCPListenerAttributeResult::getFailoverThreshold()const
 {
-	return scheduler_;
+	return failoverThreshold_;
+}
+
+bool DescribeLoadBalancerTCPListenerAttributeResult::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+int DescribeLoadBalancerTCPListenerAttributeResult::getUnhealthyThreshold()const
+{
+	return unhealthyThreshold_;
 }
 
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()const
@@ -148,16 +176,36 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckURI()c
 	return healthCheckURI_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getScheduler()const
+{
+	return scheduler_;
+}
+
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheck()const
 {
 	return healthCheck_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getWorkingServerGroupId()const
+{
+	return workingServerGroupId_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getBackendServerPort()const
 {
 	return backendServerPort_;
 }
 
+bool DescribeLoadBalancerTCPListenerAttributeResult::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+bool DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckTcpFastCloseEnabled()const
+{
+	return healthCheckTcpFastCloseEnabled_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getConnectionDrainTimeout()const
 {
 	return connectionDrainTimeout_;
@@ -173,6 +221,11 @@ int DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckConnectPort()c
 	return healthCheckConnectPort_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
 std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckMethod()const
 {
 	return healthCheckMethod_;
@@ -188,6 +241,11 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getHealthCheckHttpCo
 	return healthCheckHttpCode_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getEstablishedTimeout()const
 {
 	return establishedTimeout_;
@@ -238,6 +296,11 @@ std::string DescribeLoadBalancerTCPListenerAttributeResult::getVpcIds()const
 	return vpcIds_;
 }
 
+std::string DescribeLoadBalancerTCPListenerAttributeResult::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
 int DescribeLoadBalancerTCPListenerAttributeResult::getHealthyThreshold()const
 {
 	return healthyThreshold_;

slb/src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc

@@ -43,63 +43,93 @@ void DescribeLoadBalancerUDPListenerAttributeResult::parse(const std::string &pa
 	for (auto valuePortRangesPortRange : allPortRangesNode)
 	{
 		PortRange portRangesObject;
-		if(!valuePortRangesPortRange["StartPort"].isNull())
-			portRangesObject.startPort = std::stoi(valuePortRangesPortRange["StartPort"].asString());
 		if(!valuePortRangesPortRange["EndPort"].isNull())
 			portRangesObject.endPort = std::stoi(valuePortRangesPortRange["EndPort"].asString());
+		if(!valuePortRangesPortRange["StartPort"].isNull())
+			portRangesObject.startPort = std::stoi(valuePortRangesPortRange["StartPort"].asString());
 		portRanges_.push_back(portRangesObject);
 	}
 	auto allAclIds = value["AclIds"]["AclId"];
 	for (const auto &item : allAclIds)
 		aclIds_.push_back(item.asString());
-	if(!value["ListenerPort"].isNull())
-		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["AclId"].isNull())
+		aclId_ = value["AclId"].asString();
+	if(!value["AclStatus"].isNull())
+		aclStatus_ = value["AclStatus"].asString();
+	if(!value["AclType"].isNull())
+		aclType_ = value["AclType"].asString();
 	if(!value["BackendServerPort"].isNull())
 		backendServerPort_ = std::stoi(value["BackendServerPort"].asString());
-	if(!value["Status"].isNull())
-		status_ = value["Status"].asString();
 	if(!value["Bandwidth"].isNull())
 		bandwidth_ = std::stoi(value["Bandwidth"].asString());
-	if(!value["Scheduler"].isNull())
-		scheduler_ = value["Scheduler"].asString();
-	if(!value["PersistenceTimeout"].isNull())
-		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["ConnectionDrain"].isNull())
+		connectionDrain_ = value["ConnectionDrain"].asString();
+	if(!value["ConnectionDrainTimeout"].isNull())
+		connectionDrainTimeout_ = std::stoi(value["ConnectionDrainTimeout"].asString());
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["FailoverStrategy"].isNull())
+		failoverStrategy_ = value["FailoverStrategy"].asString();
+	if(!value["FailoverThreshold"].isNull())
+		failoverThreshold_ = std::stoi(value["FailoverThreshold"].asString());
 	if(!value["HealthCheck"].isNull())
 		healthCheck_ = value["HealthCheck"].asString();
-	if(!value["HealthyThreshold"].isNull())
-		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
-	if(!value["UnhealthyThreshold"].isNull())
-		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
-	if(!value["HealthCheckConnectTimeout"].isNull())
-		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
 	if(!value["HealthCheckConnectPort"].isNull())
 		healthCheckConnectPort_ = std::stoi(value["HealthCheckConnectPort"].asString());
+	if(!value["HealthCheckConnectTimeout"].isNull())
+		healthCheckConnectTimeout_ = std::stoi(value["HealthCheckConnectTimeout"].asString());
+	if(!value["HealthCheckDomain"].isNull())
+		healthCheckDomain_ = value["HealthCheckDomain"].asString();
+	if(!value["HealthCheckExp"].isNull())
+		healthCheckExp_ = value["HealthCheckExp"].asString();
+	if(!value["HealthCheckHttpCode"].isNull())
+		healthCheckHttpCode_ = value["HealthCheckHttpCode"].asString();
 	if(!value["HealthCheckInterval"].isNull())
 		healthCheckInterval_ = std::stoi(value["HealthCheckInterval"].asString());
+	if(!value["HealthCheckMethod"].isNull())
+		healthCheckMethod_ = value["HealthCheckMethod"].asString();
 	if(!value["HealthCheckReq"].isNull())
 		healthCheckReq_ = value["HealthCheckReq"].asString();
-	if(!value["HealthCheckExp"].isNull())
-		healthCheckExp_ = value["HealthCheckExp"].asString();
+	if(!value["HealthCheckType"].isNull())
+		healthCheckType_ = value["HealthCheckType"].asString();
+	if(!value["HealthCheckURI"].isNull())
+		healthCheckURI_ = value["HealthCheckURI"].asString();
+	if(!value["HealthyThreshold"].isNull())
+		healthyThreshold_ = std::stoi(value["HealthyThreshold"].asString());
+	if(!value["ListenerPort"].isNull())
+		listenerPort_ = std::stoi(value["ListenerPort"].asString());
+	if(!value["MasterServerGroupId"].isNull())
+		masterServerGroupId_ = value["MasterServerGroupId"].asString();
+	if(!value["MasterSlaveModeEnabled"].isNull())
+		masterSlaveModeEnabled_ = value["MasterSlaveModeEnabled"].asString() == "true";
+	if(!value["MasterSlaveServerGroupId"].isNull())
+		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
 	if(!value["MaxConnection"].isNull())
 		maxConnection_ = std::stoi(value["MaxConnection"].asString());
+	if(!value["PersistenceTimeout"].isNull())
+		persistenceTimeout_ = std::stoi(value["PersistenceTimeout"].asString());
+	if(!value["ProxyProtocolV2Enabled"].isNull())
+		proxyProtocolV2Enabled_ = value["ProxyProtocolV2Enabled"].asString() == "true";
+	if(!value["ProxyProtocolVpcIdEnabled"].isNull())
+		proxyProtocolVpcIdEnabled_ = value["ProxyProtocolVpcIdEnabled"].asString() == "true";
+	if(!value["QuicVersion"].isNull())
+		quicVersion_ = value["QuicVersion"].asString();
+	if(!value["Scheduler"].isNull())
+		scheduler_ = value["Scheduler"].asString();
+	if(!value["SlaveServerGroupId"].isNull())
+		slaveServerGroupId_ = value["SlaveServerGroupId"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["UnhealthyThreshold"].isNull())
+		unhealthyThreshold_ = std::stoi(value["UnhealthyThreshold"].asString());
 	if(!value["VServerGroupId"].isNull())
 		vServerGroupId_ = value["VServerGroupId"].asString();
-	if(!value["MasterSlaveServerGroupId"].isNull())
-		masterSlaveServerGroupId_ = value["MasterSlaveServerGroupId"].asString();
-	if(!value["AclId"].isNull())
-		aclId_ = value["AclId"].asString();
-	if(!value["AclType"].isNull())
-		aclType_ = value["AclType"].asString();
-	if(!value["AclStatus"].isNull())
-		aclStatus_ = value["AclStatus"].asString();
 	if(!value["VpcIds"].isNull())
 		vpcIds_ = value["VpcIds"].asString();
-	if(!value["Description"].isNull())
-		description_ = value["Description"].asString();
-	if(!value["ConnectionDrain"].isNull())
-		connectionDrain_ = value["ConnectionDrain"].asString();
-	if(!value["ConnectionDrainTimeout"].isNull())
-		connectionDrainTimeout_ = std::stoi(value["ConnectionDrainTimeout"].asString());
+	if(!value["WorkingServerGroupId"].isNull())
+		workingServerGroupId_ = value["WorkingServerGroupId"].asString();
+	if(!value["HealthCheckSwitch"].isNull())
+		healthCheckSwitch_ = value["HealthCheckSwitch"].asString();
 
 }
 
@@ -113,16 +143,36 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getVServerGroupId()c
 	return vServerGroupId_;
 }
 
+bool DescribeLoadBalancerUDPListenerAttributeResult::getProxyProtocolVpcIdEnabled()const
+{
+	return proxyProtocolVpcIdEnabled_;
+}
+
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getDescription()const
 {
 	return description_;
 }
 
+int DescribeLoadBalancerUDPListenerAttributeResult::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
+bool DescribeLoadBalancerUDPListenerAttributeResult::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
 int DescribeLoadBalancerUDPListenerAttributeResult::getUnhealthyThreshold()const
 {
 	return unhealthyThreshold_;
 }
 
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getScheduler()const
 {
 	return scheduler_;
@@ -133,11 +183,21 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheck()cons
 	return healthCheck_;
 }
 
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getWorkingServerGroupId()const
+{
+	return workingServerGroupId_;
+}
+
 int DescribeLoadBalancerUDPListenerAttributeResult::getBackendServerPort()const
 {
 	return backendServerPort_;
 }
 
+bool DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
 int DescribeLoadBalancerUDPListenerAttributeResult::getConnectionDrainTimeout()const
 {
 	return connectionDrainTimeout_;
@@ -153,11 +213,36 @@ int DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckConnectPort()c
 	return healthCheckConnectPort_;
 }
 
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
 int DescribeLoadBalancerUDPListenerAttributeResult::getBandwidth()const
 {
 	return bandwidth_;
 }
 
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getQuicVersion()const
+{
+	return quicVersion_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getStatus()const
 {
 	return status_;
@@ -193,9 +278,9 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getConnectionDrain()
 	return connectionDrain_;
 }
 
-std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckSwitch()const
 {
-	return healthCheckReq_;
+	return healthCheckSwitch_;
 }
 
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclStatus()const
@@ -203,14 +288,19 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getAclStatus()const
 	return aclStatus_;
 }
 
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckReq()const
+{
+	return healthCheckReq_;
+}
+
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getVpcIds()const
 {
 	return vpcIds_;
 }
 
-int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getFailoverStrategy()const
 {
-	return healthyThreshold_;
+	return failoverStrategy_;
 }
 
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()const
@@ -218,6 +308,16 @@ std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckExp()c
 	return healthCheckExp_;
 }
 
+int DescribeLoadBalancerUDPListenerAttributeResult::getHealthyThreshold()const
+{
+	return healthyThreshold_;
+}
+
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
 std::string DescribeLoadBalancerUDPListenerAttributeResult::getMasterSlaveServerGroupId()const
 {
 	return masterSlaveServerGroupId_;
@@ -233,3 +333,8 @@ std::vector<std::string> DescribeLoadBalancerUDPListenerAttributeResult::getAclI
 	return aclIds_;
 }
 
+std::string DescribeLoadBalancerUDPListenerAttributeResult::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+

slb/src/model/DescribeLoadBalancersRequest.cc

@@ -307,6 +307,17 @@ void DescribeLoadBalancersRequest::setResourceOwnerAccount(const std::string& re
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
+bool DescribeLoadBalancersRequest::getFilterByTagOrName()const
+{
+	return filterByTagOrName_;
+}
+
+void DescribeLoadBalancersRequest::setFilterByTagOrName(bool filterByTagOrName)
+{
+	filterByTagOrName_ = filterByTagOrName;
+	setParameter("FilterByTagOrName", filterByTagOrName ? "true" : "false");
+}
+
 std::string DescribeLoadBalancersRequest::getOwnerAccount()const
 {
 	return ownerAccount_;

slb/src/model/DescribeLoadBalancersResult.cc

@@ -85,6 +85,12 @@ void DescribeLoadBalancersResult::parse(const std::string &payload)
 			loadBalancersObject.modificationProtectionStatus = valueLoadBalancersLoadBalancer["ModificationProtectionStatus"].asString();
 		if(!valueLoadBalancersLoadBalancer["ModificationProtectionReason"].isNull())
 			loadBalancersObject.modificationProtectionReason = valueLoadBalancersLoadBalancer["ModificationProtectionReason"].asString();
+		if(!valueLoadBalancersLoadBalancer["Bandwidth"].isNull())
+			loadBalancersObject.bandwidth = std::stoi(valueLoadBalancersLoadBalancer["Bandwidth"].asString());
+		if(!valueLoadBalancersLoadBalancer["InternetChargeTypeAlias"].isNull())
+			loadBalancersObject.internetChargeTypeAlias = valueLoadBalancersLoadBalancer["InternetChargeTypeAlias"].asString();
+		if(!valueLoadBalancersLoadBalancer["LoadBalancerSpec"].isNull())
+			loadBalancersObject.loadBalancerSpec = valueLoadBalancersLoadBalancer["LoadBalancerSpec"].asString();
 		auto allTagsNode = valueLoadBalancersLoadBalancer["Tags"]["Tag"];
 		for (auto valueLoadBalancersLoadBalancerTagsTag : allTagsNode)
 		{

slb/src/model/DescribeVServerGroupAttributeResult.cc

@@ -61,6 +61,8 @@ void DescribeVServerGroupAttributeResult::parse(const std::string &payload)
 			backendServersObject.serverRegionId = valueBackendServersBackendServer["ServerRegionId"].asString();
 		if(!valueBackendServersBackendServer["Description"].isNull())
 			backendServersObject.description = valueBackendServersBackendServer["Description"].asString();
+		if(!valueBackendServersBackendServer["ProxyProtocolV2Enabled"].isNull())
+			backendServersObject.proxyProtocolV2Enabled = valueBackendServersBackendServer["ProxyProtocolV2Enabled"].asString() == "true";
 		backendServers_.push_back(backendServersObject);
 	}
 	if(!value["VServerGroupId"].isNull())

slb/src/model/SetLoadBalancerTCPListenerAttributeRequest.cc

@@ -60,6 +60,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setAclStatus(const std::string&
 	setParameter("AclStatus", aclStatus);
 }
 
+bool SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckTcpFastCloseEnabled()const
+{
+	return healthCheckTcpFastCloseEnabled_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled)
+{
+	healthCheckTcpFastCloseEnabled_ = healthCheckTcpFastCloseEnabled;
+	setParameter("HealthCheckTcpFastCloseEnabled", healthCheckTcpFastCloseEnabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getAclType()const
 {
 	return aclType_;
@@ -93,6 +104,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setEstablishedTimeout(int estab
 	setParameter("EstablishedTimeout", std::to_string(establishedTimeout));
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setFailoverStrategy(const std::string& failoverStrategy)
+{
+	failoverStrategy_ = failoverStrategy;
+	setParameter("FailoverStrategy", failoverStrategy);
+}
+
 int SetLoadBalancerTCPListenerAttributeRequest::getPersistenceTimeout()const
 {
 	return persistenceTimeout_;
@@ -115,6 +137,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setVpcIds(const std::string& vp
 	setParameter("VpcIds", vpcIds);
 }
 
+bool SetLoadBalancerTCPListenerAttributeRequest::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setMasterSlaveModeEnabled(bool masterSlaveModeEnabled)
+{
+	masterSlaveModeEnabled_ = masterSlaveModeEnabled;
+	setParameter("MasterSlaveModeEnabled", masterSlaveModeEnabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -197,6 +230,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+bool SetLoadBalancerTCPListenerAttributeRequest::getProxyProtocolVpcIdEnabled()const
+{
+	return proxyProtocolVpcIdEnabled_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled)
+{
+	proxyProtocolVpcIdEnabled_ = proxyProtocolVpcIdEnabled;
+	setParameter("ProxyProtocolVpcIdEnabled", proxyProtocolVpcIdEnabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getTags()const
 {
 	return tags_;
@@ -241,6 +285,28 @@ void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckInterval(int heal
 	setParameter("HealthCheckInterval", std::to_string(healthCheckInterval));
 }
 
+int SetLoadBalancerTCPListenerAttributeRequest::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setFailoverThreshold(int failoverThreshold)
+{
+	failoverThreshold_ = failoverThreshold;
+	setParameter("FailoverThreshold", std::to_string(failoverThreshold));
+}
+
+bool SetLoadBalancerTCPListenerAttributeRequest::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled)
+{
+	proxyProtocolV2Enabled_ = proxyProtocolV2Enabled;
+	setParameter("ProxyProtocolV2Enabled", proxyProtocolV2Enabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getConnectionDrain()const
 {
 	return connectionDrain_;
@@ -252,6 +318,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setConnectionDrain(const std::s
 	setParameter("ConnectionDrain", connectionDrain);
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getHealthCheckSwitch()const
+{
+	return healthCheckSwitch_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckSwitch(const std::string& healthCheckSwitch)
+{
+	healthCheckSwitch_ = healthCheckSwitch;
+	setParameter("HealthCheckSwitch", healthCheckSwitch);
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getAccess_key_id()const
 {
 	return access_key_id_;
@@ -274,6 +351,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setHealthCheckConnectTimeout(in
 	setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout));
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setSlaveServerGroupId(const std::string& slaveServerGroupId)
+{
+	slaveServerGroupId_ = slaveServerGroupId;
+	setParameter("SlaveServerGroupId", slaveServerGroupId);
+}
+
 std::string SetLoadBalancerTCPListenerAttributeRequest::getDescription()const
 {
 	return description_;
@@ -340,6 +428,17 @@ void SetLoadBalancerTCPListenerAttributeRequest::setRegionId(const std::string&
 	setParameter("RegionId", regionId);
 }
 
+std::string SetLoadBalancerTCPListenerAttributeRequest::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+void SetLoadBalancerTCPListenerAttributeRequest::setMasterServerGroupId(const std::string& masterServerGroupId)
+{
+	masterServerGroupId_ = masterServerGroupId;
+	setParameter("MasterServerGroupId", masterServerGroupId);
+}
+
 int SetLoadBalancerTCPListenerAttributeRequest::getListenerPort()const
 {
 	return listenerPort_;

slb/src/model/SetLoadBalancerUDPListenerAttributeRequest.cc

@@ -38,6 +38,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setResourceOwnerId(long resourc
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckURI()const
+{
+	return healthCheckURI_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckURI(const std::string& healthCheckURI)
+{
+	healthCheckURI_ = healthCheckURI;
+	setParameter("HealthCheckURI", healthCheckURI);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getAclStatus()const
 {
 	return aclStatus_;
@@ -71,6 +82,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setMasterSlaveServerGroup(const
 	setParameter("MasterSlaveServerGroup", masterSlaveServerGroup);
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getFailoverStrategy()const
+{
+	return failoverStrategy_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setFailoverStrategy(const std::string& failoverStrategy)
+{
+	failoverStrategy_ = failoverStrategy;
+	setParameter("FailoverStrategy", failoverStrategy);
+}
+
 int SetLoadBalancerUDPListenerAttributeRequest::getPersistenceTimeout()const
 {
 	return persistenceTimeout_;
@@ -93,6 +115,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setVpcIds(const std::string& vp
 	setParameter("VpcIds", vpcIds);
 }
 
+bool SetLoadBalancerUDPListenerAttributeRequest::getMasterSlaveModeEnabled()const
+{
+	return masterSlaveModeEnabled_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setMasterSlaveModeEnabled(bool masterSlaveModeEnabled)
+{
+	masterSlaveModeEnabled_ = masterSlaveModeEnabled;
+	setParameter("MasterSlaveModeEnabled", masterSlaveModeEnabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getVServerGroupId()const
 {
 	return vServerGroupId_;
@@ -131,6 +164,28 @@ void SetLoadBalancerUDPListenerAttributeRequest::setPortRange(const std::vector<
 	}
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckMethod()const
+{
+	return healthCheckMethod_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckMethod(const std::string& healthCheckMethod)
+{
+	healthCheckMethod_ = healthCheckMethod;
+	setParameter("HealthCheckMethod", healthCheckMethod);
+}
+
+std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckDomain()const
+{
+	return healthCheckDomain_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckDomain(const std::string& healthCheckDomain)
+{
+	healthCheckDomain_ = healthCheckDomain;
+	setParameter("HealthCheckDomain", healthCheckDomain);
+}
+
 long SetLoadBalancerUDPListenerAttributeRequest::getOwnerId()const
 {
 	return ownerId_;
@@ -142,6 +197,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
+bool SetLoadBalancerUDPListenerAttributeRequest::getProxyProtocolVpcIdEnabled()const
+{
+	return proxyProtocolVpcIdEnabled_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setProxyProtocolVpcIdEnabled(bool proxyProtocolVpcIdEnabled)
+{
+	proxyProtocolVpcIdEnabled_ = proxyProtocolVpcIdEnabled;
+	setParameter("ProxyProtocolVpcIdEnabled", proxyProtocolVpcIdEnabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getTags()const
 {
 	return tags_;
@@ -208,6 +274,28 @@ void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckExp(const std::st
 	setParameter("HealthCheckExp", healthCheckExp);
 }
 
+int SetLoadBalancerUDPListenerAttributeRequest::getFailoverThreshold()const
+{
+	return failoverThreshold_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setFailoverThreshold(int failoverThreshold)
+{
+	failoverThreshold_ = failoverThreshold;
+	setParameter("FailoverThreshold", std::to_string(failoverThreshold));
+}
+
+bool SetLoadBalancerUDPListenerAttributeRequest::getProxyProtocolV2Enabled()const
+{
+	return proxyProtocolV2Enabled_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled)
+{
+	proxyProtocolV2Enabled_ = proxyProtocolV2Enabled;
+	setParameter("ProxyProtocolV2Enabled", proxyProtocolV2Enabled ? "true" : "false");
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getConnectionDrain()const
 {
 	return connectionDrain_;
@@ -219,6 +307,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setConnectionDrain(const std::s
 	setParameter("ConnectionDrain", connectionDrain);
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckSwitch()const
+{
+	return healthCheckSwitch_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckSwitch(const std::string& healthCheckSwitch)
+{
+	healthCheckSwitch_ = healthCheckSwitch;
+	setParameter("HealthCheckSwitch", healthCheckSwitch);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getAccess_key_id()const
 {
 	return access_key_id_;
@@ -241,6 +340,28 @@ void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckConnectTimeout(in
 	setParameter("HealthCheckConnectTimeout", std::to_string(healthCheckConnectTimeout));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getSlaveServerGroupId()const
+{
+	return slaveServerGroupId_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setSlaveServerGroupId(const std::string& slaveServerGroupId)
+{
+	slaveServerGroupId_ = slaveServerGroupId;
+	setParameter("SlaveServerGroupId", slaveServerGroupId);
+}
+
+std::string SetLoadBalancerUDPListenerAttributeRequest::getQuicVersion()const
+{
+	return quicVersion_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setQuicVersion(const std::string& quicVersion)
+{
+	quicVersion_ = quicVersion;
+	setParameter("QuicVersion", quicVersion);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getDescription()const
 {
 	return description_;
@@ -307,6 +428,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setRegionId(const std::string&
 	setParameter("RegionId", regionId);
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getMasterServerGroupId()const
+{
+	return masterServerGroupId_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setMasterServerGroupId(const std::string& masterServerGroupId)
+{
+	masterServerGroupId_ = masterServerGroupId;
+	setParameter("MasterServerGroupId", masterServerGroupId);
+}
+
 int SetLoadBalancerUDPListenerAttributeRequest::getListenerPort()const
 {
 	return listenerPort_;
@@ -318,6 +450,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setListenerPort(int listenerPor
 	setParameter("ListenerPort", std::to_string(listenerPort));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckType()const
+{
+	return healthCheckType_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckType(const std::string& healthCheckType)
+{
+	healthCheckType_ = healthCheckType;
+	setParameter("HealthCheckType", healthCheckType);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -373,6 +516,17 @@ void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckConnectPort(int h
 	setParameter("HealthCheckConnectPort", std::to_string(healthCheckConnectPort));
 }
 
+std::string SetLoadBalancerUDPListenerAttributeRequest::getHealthCheckHttpCode()const
+{
+	return healthCheckHttpCode_;
+}
+
+void SetLoadBalancerUDPListenerAttributeRequest::setHealthCheckHttpCode(const std::string& healthCheckHttpCode)
+{
+	healthCheckHttpCode_ = healthCheckHttpCode;
+	setParameter("HealthCheckHttpCode", healthCheckHttpCode);
+}
+
 std::string SetLoadBalancerUDPListenerAttributeRequest::getVServerGroup()const
 {
 	return vServerGroup_;