Update HDENI and LENI API.

VERSION

@@ -1 +1 @@
-1.36.1901
+1.36.1902

eflo/CMakeLists.txt

@@ -21,6 +21,8 @@ set(eflo_public_header
 	include/alibabacloud/eflo/EfloExport.h )
 
 set(eflo_public_header_model 
+	include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/AssignPrivateIpAddressRequest.h
 	include/alibabacloud/eflo/model/AssignPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/AssociateVpdCidrBlockRequest.h
@@ -77,6 +79,8 @@ set(eflo_public_header_model
 	include/alibabacloud/eflo/model/GetErRouteMapResult.h
 	include/alibabacloud/eflo/model/GetFabricTopologyRequest.h
 	include/alibabacloud/eflo/model/GetFabricTopologyResult.h
+	include/alibabacloud/eflo/model/GetLeniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/GetLeniPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/GetLniPrivateIpAddressRequest.h
 	include/alibabacloud/eflo/model/GetLniPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/GetNetworkInterfaceRequest.h
@@ -111,6 +115,8 @@ set(eflo_public_header_model
 	include/alibabacloud/eflo/model/ListErsResult.h
 	include/alibabacloud/eflo/model/ListInstancesByNcdRequest.h
 	include/alibabacloud/eflo/model/ListInstancesByNcdResult.h
+	include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesRequest.h
+	include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesResult.h
 	include/alibabacloud/eflo/model/ListLniPrivateIpAddressRequest.h
 	include/alibabacloud/eflo/model/ListLniPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/ListNetworkInterfacesRequest.h
@@ -137,6 +143,8 @@ set(eflo_public_header_model
 	include/alibabacloud/eflo/model/UnAssignPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockRequest.h
 	include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockResult.h
+	include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceRequest.h
 	include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceResult.h
 	include/alibabacloud/eflo/model/UpdateErRequest.h
@@ -145,6 +153,8 @@ set(eflo_public_header_model
 	include/alibabacloud/eflo/model/UpdateErAttachmentResult.h
 	include/alibabacloud/eflo/model/UpdateErRouteMapRequest.h
 	include/alibabacloud/eflo/model/UpdateErRouteMapResult.h
+	include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressResult.h
 	include/alibabacloud/eflo/model/UpdateSubnetRequest.h
 	include/alibabacloud/eflo/model/UpdateSubnetResult.h
 	include/alibabacloud/eflo/model/UpdateVccRequest.h
@@ -154,6 +164,8 @@ set(eflo_public_header_model
 
 set(eflo_src 
 	src/EfloClient.cc
+	src/model/AssignLeniPrivateIpAddressRequest.cc
+	src/model/AssignLeniPrivateIpAddressResult.cc
 	src/model/AssignPrivateIpAddressRequest.cc
 	src/model/AssignPrivateIpAddressResult.cc
 	src/model/AssociateVpdCidrBlockRequest.cc
@@ -210,6 +222,8 @@ set(eflo_src
 	src/model/GetErRouteMapResult.cc
 	src/model/GetFabricTopologyRequest.cc
 	src/model/GetFabricTopologyResult.cc
+	src/model/GetLeniPrivateIpAddressRequest.cc
+	src/model/GetLeniPrivateIpAddressResult.cc
 	src/model/GetLniPrivateIpAddressRequest.cc
 	src/model/GetLniPrivateIpAddressResult.cc
 	src/model/GetNetworkInterfaceRequest.cc
@@ -244,6 +258,8 @@ set(eflo_src
 	src/model/ListErsResult.cc
 	src/model/ListInstancesByNcdRequest.cc
 	src/model/ListInstancesByNcdResult.cc
+	src/model/ListLeniPrivateIpAddressesRequest.cc
+	src/model/ListLeniPrivateIpAddressesResult.cc
 	src/model/ListLniPrivateIpAddressRequest.cc
 	src/model/ListLniPrivateIpAddressResult.cc
 	src/model/ListNetworkInterfacesRequest.cc
@@ -270,6 +286,8 @@ set(eflo_src
 	src/model/UnAssignPrivateIpAddressResult.cc
 	src/model/UnAssociateVpdCidrBlockRequest.cc
 	src/model/UnAssociateVpdCidrBlockResult.cc
+	src/model/UnassignLeniPrivateIpAddressRequest.cc
+	src/model/UnassignLeniPrivateIpAddressResult.cc
 	src/model/UpdateElasticNetworkInterfaceRequest.cc
 	src/model/UpdateElasticNetworkInterfaceResult.cc
 	src/model/UpdateErRequest.cc
@@ -278,6 +296,8 @@ set(eflo_src
 	src/model/UpdateErAttachmentResult.cc
 	src/model/UpdateErRouteMapRequest.cc
 	src/model/UpdateErRouteMapResult.cc
+	src/model/UpdateLeniPrivateIpAddressRequest.cc
+	src/model/UpdateLeniPrivateIpAddressResult.cc
 	src/model/UpdateSubnetRequest.cc
 	src/model/UpdateSubnetResult.cc
 	src/model/UpdateVccRequest.cc

eflo/include/alibabacloud/eflo/EfloClient.h

@@ -22,6 +22,8 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "EfloExport.h"
+#include "model/AssignLeniPrivateIpAddressRequest.h"
+#include "model/AssignLeniPrivateIpAddressResult.h"
 #include "model/AssignPrivateIpAddressRequest.h"
 #include "model/AssignPrivateIpAddressResult.h"
 #include "model/AssociateVpdCidrBlockRequest.h"
@@ -78,6 +80,8 @@
 #include "model/GetErRouteMapResult.h"
 #include "model/GetFabricTopologyRequest.h"
 #include "model/GetFabricTopologyResult.h"
+#include "model/GetLeniPrivateIpAddressRequest.h"
+#include "model/GetLeniPrivateIpAddressResult.h"
 #include "model/GetLniPrivateIpAddressRequest.h"
 #include "model/GetLniPrivateIpAddressResult.h"
 #include "model/GetNetworkInterfaceRequest.h"
@@ -112,6 +116,8 @@
 #include "model/ListErsResult.h"
 #include "model/ListInstancesByNcdRequest.h"
 #include "model/ListInstancesByNcdResult.h"
+#include "model/ListLeniPrivateIpAddressesRequest.h"
+#include "model/ListLeniPrivateIpAddressesResult.h"
 #include "model/ListLniPrivateIpAddressRequest.h"
 #include "model/ListLniPrivateIpAddressResult.h"
 #include "model/ListNetworkInterfacesRequest.h"
@@ -138,6 +144,8 @@
 #include "model/UnAssignPrivateIpAddressResult.h"
 #include "model/UnAssociateVpdCidrBlockRequest.h"
 #include "model/UnAssociateVpdCidrBlockResult.h"
+#include "model/UnassignLeniPrivateIpAddressRequest.h"
+#include "model/UnassignLeniPrivateIpAddressResult.h"
 #include "model/UpdateElasticNetworkInterfaceRequest.h"
 #include "model/UpdateElasticNetworkInterfaceResult.h"
 #include "model/UpdateErRequest.h"
@@ -146,6 +154,8 @@
 #include "model/UpdateErAttachmentResult.h"
 #include "model/UpdateErRouteMapRequest.h"
 #include "model/UpdateErRouteMapResult.h"
+#include "model/UpdateLeniPrivateIpAddressRequest.h"
+#include "model/UpdateLeniPrivateIpAddressResult.h"
 #include "model/UpdateSubnetRequest.h"
 #include "model/UpdateSubnetResult.h"
 #include "model/UpdateVccRequest.h"
@@ -161,6 +171,9 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_EFLO_EXPORT EfloClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AssignLeniPrivateIpAddressResult> AssignLeniPrivateIpAddressOutcome;
+			typedef std::future<AssignLeniPrivateIpAddressOutcome> AssignLeniPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::AssignLeniPrivateIpAddressRequest&, const AssignLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssignLeniPrivateIpAddressAsyncHandler;
 			typedef Outcome<Error, Model::AssignPrivateIpAddressResult> AssignPrivateIpAddressOutcome;
 			typedef std::future<AssignPrivateIpAddressOutcome> AssignPrivateIpAddressOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::AssignPrivateIpAddressRequest&, const AssignPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssignPrivateIpAddressAsyncHandler;
@@ -245,6 +258,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetFabricTopologyResult> GetFabricTopologyOutcome;
 			typedef std::future<GetFabricTopologyOutcome> GetFabricTopologyOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetFabricTopologyRequest&, const GetFabricTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFabricTopologyAsyncHandler;
+			typedef Outcome<Error, Model::GetLeniPrivateIpAddressResult> GetLeniPrivateIpAddressOutcome;
+			typedef std::future<GetLeniPrivateIpAddressOutcome> GetLeniPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetLeniPrivateIpAddressRequest&, const GetLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLeniPrivateIpAddressAsyncHandler;
 			typedef Outcome<Error, Model::GetLniPrivateIpAddressResult> GetLniPrivateIpAddressOutcome;
 			typedef std::future<GetLniPrivateIpAddressOutcome> GetLniPrivateIpAddressOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetLniPrivateIpAddressRequest&, const GetLniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLniPrivateIpAddressAsyncHandler;
@@ -296,6 +312,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListInstancesByNcdResult> ListInstancesByNcdOutcome;
 			typedef std::future<ListInstancesByNcdOutcome> ListInstancesByNcdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListInstancesByNcdRequest&, const ListInstancesByNcdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesByNcdAsyncHandler;
+			typedef Outcome<Error, Model::ListLeniPrivateIpAddressesResult> ListLeniPrivateIpAddressesOutcome;
+			typedef std::future<ListLeniPrivateIpAddressesOutcome> ListLeniPrivateIpAddressesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListLeniPrivateIpAddressesRequest&, const ListLeniPrivateIpAddressesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLeniPrivateIpAddressesAsyncHandler;
 			typedef Outcome<Error, Model::ListLniPrivateIpAddressResult> ListLniPrivateIpAddressOutcome;
 			typedef std::future<ListLniPrivateIpAddressOutcome> ListLniPrivateIpAddressOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListLniPrivateIpAddressRequest&, const ListLniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListLniPrivateIpAddressAsyncHandler;
@@ -335,6 +354,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UnAssociateVpdCidrBlockResult> UnAssociateVpdCidrBlockOutcome;
 			typedef std::future<UnAssociateVpdCidrBlockOutcome> UnAssociateVpdCidrBlockOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::UnAssociateVpdCidrBlockRequest&, const UnAssociateVpdCidrBlockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnAssociateVpdCidrBlockAsyncHandler;
+			typedef Outcome<Error, Model::UnassignLeniPrivateIpAddressResult> UnassignLeniPrivateIpAddressOutcome;
+			typedef std::future<UnassignLeniPrivateIpAddressOutcome> UnassignLeniPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UnassignLeniPrivateIpAddressRequest&, const UnassignLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnassignLeniPrivateIpAddressAsyncHandler;
 			typedef Outcome<Error, Model::UpdateElasticNetworkInterfaceResult> UpdateElasticNetworkInterfaceOutcome;
 			typedef std::future<UpdateElasticNetworkInterfaceOutcome> UpdateElasticNetworkInterfaceOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::UpdateElasticNetworkInterfaceRequest&, const UpdateElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateElasticNetworkInterfaceAsyncHandler;
@@ -347,6 +369,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateErRouteMapResult> UpdateErRouteMapOutcome;
 			typedef std::future<UpdateErRouteMapOutcome> UpdateErRouteMapOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::UpdateErRouteMapRequest&, const UpdateErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErRouteMapAsyncHandler;
+			typedef Outcome<Error, Model::UpdateLeniPrivateIpAddressResult> UpdateLeniPrivateIpAddressOutcome;
+			typedef std::future<UpdateLeniPrivateIpAddressOutcome> UpdateLeniPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateLeniPrivateIpAddressRequest&, const UpdateLeniPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLeniPrivateIpAddressAsyncHandler;
 			typedef Outcome<Error, Model::UpdateSubnetResult> UpdateSubnetOutcome;
 			typedef std::future<UpdateSubnetOutcome> UpdateSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::UpdateSubnetRequest&, const UpdateSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSubnetAsyncHandler;
@@ -361,6 +386,9 @@ namespace AlibabaCloud
 			EfloClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			EfloClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~EfloClient();
+			AssignLeniPrivateIpAddressOutcome assignLeniPrivateIpAddress(const Model::AssignLeniPrivateIpAddressRequest &request)const;
+			void assignLeniPrivateIpAddressAsync(const Model::AssignLeniPrivateIpAddressRequest& request, const AssignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssignLeniPrivateIpAddressOutcomeCallable assignLeniPrivateIpAddressCallable(const Model::AssignLeniPrivateIpAddressRequest& request) const;
 			AssignPrivateIpAddressOutcome assignPrivateIpAddress(const Model::AssignPrivateIpAddressRequest &request)const;
 			void assignPrivateIpAddressAsync(const Model::AssignPrivateIpAddressRequest& request, const AssignPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AssignPrivateIpAddressOutcomeCallable assignPrivateIpAddressCallable(const Model::AssignPrivateIpAddressRequest& request) const;
@@ -445,6 +473,9 @@ namespace AlibabaCloud
 			GetFabricTopologyOutcome getFabricTopology(const Model::GetFabricTopologyRequest &request)const;
 			void getFabricTopologyAsync(const Model::GetFabricTopologyRequest& request, const GetFabricTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetFabricTopologyOutcomeCallable getFabricTopologyCallable(const Model::GetFabricTopologyRequest& request) const;
+			GetLeniPrivateIpAddressOutcome getLeniPrivateIpAddress(const Model::GetLeniPrivateIpAddressRequest &request)const;
+			void getLeniPrivateIpAddressAsync(const Model::GetLeniPrivateIpAddressRequest& request, const GetLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetLeniPrivateIpAddressOutcomeCallable getLeniPrivateIpAddressCallable(const Model::GetLeniPrivateIpAddressRequest& request) const;
 			GetLniPrivateIpAddressOutcome getLniPrivateIpAddress(const Model::GetLniPrivateIpAddressRequest &request)const;
 			void getLniPrivateIpAddressAsync(const Model::GetLniPrivateIpAddressRequest& request, const GetLniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetLniPrivateIpAddressOutcomeCallable getLniPrivateIpAddressCallable(const Model::GetLniPrivateIpAddressRequest& request) const;
@@ -496,6 +527,9 @@ namespace AlibabaCloud
 			ListInstancesByNcdOutcome listInstancesByNcd(const Model::ListInstancesByNcdRequest &request)const;
 			void listInstancesByNcdAsync(const Model::ListInstancesByNcdRequest& request, const ListInstancesByNcdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListInstancesByNcdOutcomeCallable listInstancesByNcdCallable(const Model::ListInstancesByNcdRequest& request) const;
+			ListLeniPrivateIpAddressesOutcome listLeniPrivateIpAddresses(const Model::ListLeniPrivateIpAddressesRequest &request)const;
+			void listLeniPrivateIpAddressesAsync(const Model::ListLeniPrivateIpAddressesRequest& request, const ListLeniPrivateIpAddressesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListLeniPrivateIpAddressesOutcomeCallable listLeniPrivateIpAddressesCallable(const Model::ListLeniPrivateIpAddressesRequest& request) const;
 			ListLniPrivateIpAddressOutcome listLniPrivateIpAddress(const Model::ListLniPrivateIpAddressRequest &request)const;
 			void listLniPrivateIpAddressAsync(const Model::ListLniPrivateIpAddressRequest& request, const ListLniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListLniPrivateIpAddressOutcomeCallable listLniPrivateIpAddressCallable(const Model::ListLniPrivateIpAddressRequest& request) const;
@@ -535,6 +569,9 @@ namespace AlibabaCloud
 			UnAssociateVpdCidrBlockOutcome unAssociateVpdCidrBlock(const Model::UnAssociateVpdCidrBlockRequest &request)const;
 			void unAssociateVpdCidrBlockAsync(const Model::UnAssociateVpdCidrBlockRequest& request, const UnAssociateVpdCidrBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UnAssociateVpdCidrBlockOutcomeCallable unAssociateVpdCidrBlockCallable(const Model::UnAssociateVpdCidrBlockRequest& request) const;
+			UnassignLeniPrivateIpAddressOutcome unassignLeniPrivateIpAddress(const Model::UnassignLeniPrivateIpAddressRequest &request)const;
+			void unassignLeniPrivateIpAddressAsync(const Model::UnassignLeniPrivateIpAddressRequest& request, const UnassignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnassignLeniPrivateIpAddressOutcomeCallable unassignLeniPrivateIpAddressCallable(const Model::UnassignLeniPrivateIpAddressRequest& request) const;
 			UpdateElasticNetworkInterfaceOutcome updateElasticNetworkInterface(const Model::UpdateElasticNetworkInterfaceRequest &request)const;
 			void updateElasticNetworkInterfaceAsync(const Model::UpdateElasticNetworkInterfaceRequest& request, const UpdateElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateElasticNetworkInterfaceOutcomeCallable updateElasticNetworkInterfaceCallable(const Model::UpdateElasticNetworkInterfaceRequest& request) const;
@@ -547,6 +584,9 @@ namespace AlibabaCloud
 			UpdateErRouteMapOutcome updateErRouteMap(const Model::UpdateErRouteMapRequest &request)const;
 			void updateErRouteMapAsync(const Model::UpdateErRouteMapRequest& request, const UpdateErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateErRouteMapOutcomeCallable updateErRouteMapCallable(const Model::UpdateErRouteMapRequest& request) const;
+			UpdateLeniPrivateIpAddressOutcome updateLeniPrivateIpAddress(const Model::UpdateLeniPrivateIpAddressRequest &request)const;
+			void updateLeniPrivateIpAddressAsync(const Model::UpdateLeniPrivateIpAddressRequest& request, const UpdateLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateLeniPrivateIpAddressOutcomeCallable updateLeniPrivateIpAddressCallable(const Model::UpdateLeniPrivateIpAddressRequest& request) const;
 			UpdateSubnetOutcome updateSubnet(const Model::UpdateSubnetRequest &request)const;
 			void updateSubnetAsync(const Model::UpdateSubnetRequest& request, const UpdateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateSubnetOutcomeCallable updateSubnetCallable(const Model::UpdateSubnetRequest& request) const;

eflo/include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT AssignLeniPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	AssignLeniPrivateIpAddressRequest();
+	~AssignLeniPrivateIpAddressRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getPrivateIpAddress() const;
+	void setPrivateIpAddress(const std::string &privateIpAddress);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::string privateIpAddress_;
+	std::string regionId_;
+	std::string elasticNetworkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_ASSIGNLENIPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/AssignLeniPrivateIpAddressResult.h

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

eflo/include/alibabacloud/eflo/model/DeleteVpdGrantRuleRequest.h

@@ -36,17 +36,17 @@ public:
 	void setGrantTenantId(const std::string &grantTenantId);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
-	std::string getGrantRuleId() const;
-	void setGrantRuleId(const std::string &grantRuleId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	std::string getGrantRuleId() const;
+	void setGrantRuleId(const std::string &grantRuleId);
 
 private:
 	std::string erId_;
 	std::string grantTenantId_;
 	std::string instanceId_;
-	std::string grantRuleId_;
 	std::string regionId_;
+	std::string grantRuleId_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/GetElasticNetworkInterfaceResult.h

@@ -54,6 +54,7 @@ namespace AlibabaCloud
 					std::string ip;
 					std::string vSwitchId;
 					std::string createTime;
+					std::string securityGroupId;
 					std::string mask;
 					std::string gmtModified;
 					std::string mac;

eflo/include/alibabacloud/eflo/model/GetLeniPrivateIpAddressRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT GetLeniPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	GetLeniPrivateIpAddressRequest();
+	~GetLeniPrivateIpAddressRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getIpName() const;
+	void setIpName(const std::string &ipName);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+
+private:
+	std::string regionId_;
+	std::string ipName_;
+	std::string elasticNetworkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetLeniPrivateIpAddressResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eflo/EfloExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eflo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EFLO_EXPORT GetLeniPrivateIpAddressResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string elasticNetworkInterfaceId;
+					std::string gmtCreate;
+					std::string ipName;
+					std::string privateIpAddress;
+					std::string description;
+					std::string message;
+					std::string gmtModified;
+					std::string regionId;
+				};
+
+
+				GetLeniPrivateIpAddressResult();
+				explicit GetLeniPrivateIpAddressResult(const std::string &payload);
+				~GetLeniPrivateIpAddressResult();
+				std::string getMessage()const;
+				Content getContent()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Content content_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETLENIPRIVATEIPADDRESSRESULT_H_

eflo/include/alibabacloud/eflo/model/GetNodeInfoForPodResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string zoneId;
 					std::string vpcId;
+					int hdeniQuota;
 					std::string clusterId;
 					int lniSipQuota;
 					std::string nodeId;

eflo/include/alibabacloud/eflo/model/GetVccGrantRuleResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					std::string instanceName;
 					std::string tenantId;
 					std::string grantTenantId;
+					std::string resourceGroupId;
 					std::string instanceId;
 					bool used;
 					std::string createTime;

eflo/include/alibabacloud/eflo/model/GetVccRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_EFLO_EXPORT GetVccRequest : public RpcServiceRequest {
 public:
 	GetVccRequest();
 	~GetVccRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
 	std::string getRegionId() const;
@@ -42,6 +44,7 @@ public:
 	void setVccId(const std::string &vccId);
 
 private:
+	std::string clientToken_;
 	int pageNumber_;
 	std::string regionId_;
 	bool enablePage_;

eflo/include/alibabacloud/eflo/model/GetVccResult.h

@@ -84,6 +84,23 @@ namespace AlibabaCloud
 						std::string tagKey;
 						std::string tagValue;
 					};
+					struct VbrInfo
+					{
+						struct VbrBgpPeer
+						{
+							std::string status;
+							std::string bgpPeerId;
+							std::string peerIpAddress;
+							std::string peerAsn;
+							std::string bgpGroupId;
+						};
+						std::string status;
+						std::string gmtCreate;
+						std::vector<VbrInfo::VbrBgpPeer> vbrBgpPeers;
+						std::string cenId;
+						std::string gmtModified;
+						std::string vbrId;
+					};
 					std::string message;
 					std::string resourceGroupId;
 					std::string lineOperator;
@@ -112,6 +129,7 @@ namespace AlibabaCloud
 					std::string vpdId;
 					std::vector<ErInfo> erInfos;
 					std::string cenOwnerId;
+					std::vector<VbrInfo> vbrInfos;
 					bool attachErStatus;
 					std::string cenId;
 					std::string accessPointId;

eflo/include/alibabacloud/eflo/model/GetVccRouteEntryResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 					std::string nextHopType;
 					std::string tenantId;
 					std::string routeType;
+					std::string message;
 					std::string nextHopId;
 					std::string gmtModified;
 					std::string regionId;

eflo/include/alibabacloud/eflo/model/GetVpdGrantRuleResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					std::string instanceName;
 					std::string tenantId;
 					std::string grantTenantId;
+					std::string resourceGroupId;
 					std::string instanceId;
 					bool used;
 					std::string createTime;

eflo/include/alibabacloud/eflo/model/ListElasticNetworkInterfacesResult.h

@@ -43,6 +43,7 @@ namespace AlibabaCloud
 						std::string ip;
 						std::string vSwitchId;
 						std::string createTime;
+						std::string securityGroupId;
 						std::string mask;
 						std::string gmtModified;
 						std::string mac;

eflo/include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT ListLeniPrivateIpAddressesRequest : public RpcServiceRequest {
+public:
+	ListLeniPrivateIpAddressesRequest();
+	~ListLeniPrivateIpAddressesRequest();
+	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 getPrivateIpAddress() const;
+	void setPrivateIpAddress(const std::string &privateIpAddress);
+	std::string getIpName() const;
+	void setIpName(const std::string &ipName);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+	std::string privateIpAddress_;
+	std::string ipName_;
+	std::string elasticNetworkInterfaceId_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListLeniPrivateIpAddressesResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/eflo/EfloExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Eflo
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EFLO_EXPORT ListLeniPrivateIpAddressesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string elasticNetworkInterfaceId;
+						std::string gmtCreate;
+						std::string ipName;
+						std::string privateIpAddress;
+						std::string description;
+						std::string message;
+						std::string gmtModified;
+						std::string regionId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListLeniPrivateIpAddressesResult();
+				explicit ListLeniPrivateIpAddressesResult(const std::string &payload);
+				~ListLeniPrivateIpAddressesResult();
+				std::string getMessage()const;
+				Content getContent()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Content content_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTLENIPRIVATEIPADDRESSESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListVccGrantRulesRequest.h

@@ -34,6 +34,8 @@ public:
 	void setGrantTenantId(const std::string &grantTenantId);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getGrantRuleId() const;
@@ -54,6 +56,7 @@ public:
 private:
 	std::string grantTenantId_;
 	int pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::string grantRuleId_;
 	int pageSize_;

eflo/include/alibabacloud/eflo/model/ListVccGrantRulesResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 						std::string instanceName;
 						std::string tenantId;
 						std::string grantTenantId;
+						std::string resourceGroupId;
 						std::string instanceId;
 						bool used;
 						std::string createTime;

eflo/include/alibabacloud/eflo/model/ListVccRouteEntriesResult.h

@@ -42,6 +42,7 @@ namespace AlibabaCloud
 						std::string tenantId;
 						std::string resourceTenantId;
 						std::string routeType;
+						std::string message;
 						std::string nextHopId;
 						std::string gmtModified;
 						std::string vccId;

eflo/include/alibabacloud/eflo/model/ListVpdGrantRulesRequest.h

@@ -34,6 +34,8 @@ public:
 	void setGrantTenantId(const std::string &grantTenantId);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getGrantRuleId() const;
@@ -54,6 +56,7 @@ public:
 private:
 	std::string grantTenantId_;
 	int pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	std::string grantRuleId_;
 	int pageSize_;

eflo/include/alibabacloud/eflo/model/ListVpdGrantRulesResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 						std::string instanceName;
 						std::string tenantId;
 						std::string grantTenantId;
+						std::string resourceGroupId;
 						std::string instanceId;
 						bool used;
 						std::string createTime;

eflo/include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT UnassignLeniPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	UnassignLeniPrivateIpAddressRequest();
+	~UnassignLeniPrivateIpAddressRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getIpName() const;
+	void setIpName(const std::string &ipName);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::string ipName_;
+	std::string elasticNetworkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_UNASSIGNLENIPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/UnassignLeniPrivateIpAddressResult.h

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

eflo/include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSREQUEST_H_
+
+#include <alibabacloud/eflo/EfloExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Eflo {
+namespace Model {
+class ALIBABACLOUD_EFLO_EXPORT UpdateLeniPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	UpdateLeniPrivateIpAddressRequest();
+	~UpdateLeniPrivateIpAddressRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getIpName() const;
+	void setIpName(const std::string &ipName);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+
+private:
+	std::string description_;
+	std::string regionId_;
+	std::string ipName_;
+	std::string elasticNetworkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_UPDATELENIPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/UpdateLeniPrivateIpAddressResult.h

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

eflo/src/EfloClient.cc

@@ -51,6 +51,42 @@ EfloClient::EfloClient(const std::string & accessKeyId, const std::string & acce
 EfloClient::~EfloClient()
 {}
 
+EfloClient::AssignLeniPrivateIpAddressOutcome EfloClient::assignLeniPrivateIpAddress(const AssignLeniPrivateIpAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AssignLeniPrivateIpAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AssignLeniPrivateIpAddressOutcome(AssignLeniPrivateIpAddressResult(outcome.result()));
+	else
+		return AssignLeniPrivateIpAddressOutcome(outcome.error());
+}
+
+void EfloClient::assignLeniPrivateIpAddressAsync(const AssignLeniPrivateIpAddressRequest& request, const AssignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, assignLeniPrivateIpAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EfloClient::AssignLeniPrivateIpAddressOutcomeCallable EfloClient::assignLeniPrivateIpAddressCallable(const AssignLeniPrivateIpAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AssignLeniPrivateIpAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->assignLeniPrivateIpAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EfloClient::AssignPrivateIpAddressOutcome EfloClient::assignPrivateIpAddress(const AssignPrivateIpAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1095,42 @@ EfloClient::GetFabricTopologyOutcomeCallable EfloClient::getFabricTopologyCallab
 	return task->get_future();
 }
 
+EfloClient::GetLeniPrivateIpAddressOutcome EfloClient::getLeniPrivateIpAddress(const GetLeniPrivateIpAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetLeniPrivateIpAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetLeniPrivateIpAddressOutcome(GetLeniPrivateIpAddressResult(outcome.result()));
+	else
+		return GetLeniPrivateIpAddressOutcome(outcome.error());
+}
+
+void EfloClient::getLeniPrivateIpAddressAsync(const GetLeniPrivateIpAddressRequest& request, const GetLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getLeniPrivateIpAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EfloClient::GetLeniPrivateIpAddressOutcomeCallable EfloClient::getLeniPrivateIpAddressCallable(const GetLeniPrivateIpAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetLeniPrivateIpAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->getLeniPrivateIpAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EfloClient::GetLniPrivateIpAddressOutcome EfloClient::getLniPrivateIpAddress(const GetLniPrivateIpAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1743,42 @@ EfloClient::ListInstancesByNcdOutcomeCallable EfloClient::listInstancesByNcdCall
 	return task->get_future();
 }
 
+EfloClient::ListLeniPrivateIpAddressesOutcome EfloClient::listLeniPrivateIpAddresses(const ListLeniPrivateIpAddressesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListLeniPrivateIpAddressesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListLeniPrivateIpAddressesOutcome(ListLeniPrivateIpAddressesResult(outcome.result()));
+	else
+		return ListLeniPrivateIpAddressesOutcome(outcome.error());
+}
+
+void EfloClient::listLeniPrivateIpAddressesAsync(const ListLeniPrivateIpAddressesRequest& request, const ListLeniPrivateIpAddressesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listLeniPrivateIpAddresses(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EfloClient::ListLeniPrivateIpAddressesOutcomeCallable EfloClient::listLeniPrivateIpAddressesCallable(const ListLeniPrivateIpAddressesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListLeniPrivateIpAddressesOutcome()>>(
+			[this, request]()
+			{
+			return this->listLeniPrivateIpAddresses(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EfloClient::ListLniPrivateIpAddressOutcome EfloClient::listLniPrivateIpAddress(const ListLniPrivateIpAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2139,6 +2247,42 @@ EfloClient::UnAssociateVpdCidrBlockOutcomeCallable EfloClient::unAssociateVpdCid
 	return task->get_future();
 }
 
+EfloClient::UnassignLeniPrivateIpAddressOutcome EfloClient::unassignLeniPrivateIpAddress(const UnassignLeniPrivateIpAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UnassignLeniPrivateIpAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UnassignLeniPrivateIpAddressOutcome(UnassignLeniPrivateIpAddressResult(outcome.result()));
+	else
+		return UnassignLeniPrivateIpAddressOutcome(outcome.error());
+}
+
+void EfloClient::unassignLeniPrivateIpAddressAsync(const UnassignLeniPrivateIpAddressRequest& request, const UnassignLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, unassignLeniPrivateIpAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EfloClient::UnassignLeniPrivateIpAddressOutcomeCallable EfloClient::unassignLeniPrivateIpAddressCallable(const UnassignLeniPrivateIpAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UnassignLeniPrivateIpAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->unassignLeniPrivateIpAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EfloClient::UpdateElasticNetworkInterfaceOutcome EfloClient::updateElasticNetworkInterface(const UpdateElasticNetworkInterfaceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2427,42 @@ EfloClient::UpdateErRouteMapOutcomeCallable EfloClient::updateErRouteMapCallable
 	return task->get_future();
 }
 
+EfloClient::UpdateLeniPrivateIpAddressOutcome EfloClient::updateLeniPrivateIpAddress(const UpdateLeniPrivateIpAddressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateLeniPrivateIpAddressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateLeniPrivateIpAddressOutcome(UpdateLeniPrivateIpAddressResult(outcome.result()));
+	else
+		return UpdateLeniPrivateIpAddressOutcome(outcome.error());
+}
+
+void EfloClient::updateLeniPrivateIpAddressAsync(const UpdateLeniPrivateIpAddressRequest& request, const UpdateLeniPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateLeniPrivateIpAddress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EfloClient::UpdateLeniPrivateIpAddressOutcomeCallable EfloClient::updateLeniPrivateIpAddressCallable(const UpdateLeniPrivateIpAddressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateLeniPrivateIpAddressOutcome()>>(
+			[this, request]()
+			{
+			return this->updateLeniPrivateIpAddress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EfloClient::UpdateSubnetOutcome EfloClient::updateSubnet(const UpdateSubnetRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

eflo/src/model/AssignLeniPrivateIpAddressRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/AssignLeniPrivateIpAddressRequest.h>
+
+using AlibabaCloud::Eflo::Model::AssignLeniPrivateIpAddressRequest;
+
+AssignLeniPrivateIpAddressRequest::AssignLeniPrivateIpAddressRequest()
+    : RpcServiceRequest("eflo", "2022-05-30", "AssignLeniPrivateIpAddress") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AssignLeniPrivateIpAddressRequest::~AssignLeniPrivateIpAddressRequest() {}
+
+std::string AssignLeniPrivateIpAddressRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void AssignLeniPrivateIpAddressRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setBodyParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string AssignLeniPrivateIpAddressRequest::getDescription() const {
+  return description_;
+}
+
+void AssignLeniPrivateIpAddressRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string AssignLeniPrivateIpAddressRequest::getPrivateIpAddress() const {
+  return privateIpAddress_;
+}
+
+void AssignLeniPrivateIpAddressRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
+  privateIpAddress_ = privateIpAddress;
+  setBodyParameter(std::string("PrivateIpAddress"), privateIpAddress);
+}
+
+std::string AssignLeniPrivateIpAddressRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AssignLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string AssignLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
+  return elasticNetworkInterfaceId_;
+}
+
+void AssignLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
+  elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
+  setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
+}
+

eflo/src/model/AssignLeniPrivateIpAddressResult.cc

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

eflo/src/model/DeleteVpdGrantRuleRequest.cc

@@ -52,15 +52,6 @@ void DeleteVpdGrantRuleRequest::setInstanceId(const std::string &instanceId) {
   setBodyParameter(std::string("InstanceId"), instanceId);
 }
 
-std::string DeleteVpdGrantRuleRequest::getGrantRuleId() const {
-  return grantRuleId_;
-}
-
-void DeleteVpdGrantRuleRequest::setGrantRuleId(const std::string &grantRuleId) {
-  grantRuleId_ = grantRuleId;
-  setBodyParameter(std::string("GrantRuleId"), grantRuleId);
-}
-
 std::string DeleteVpdGrantRuleRequest::getRegionId() const {
   return regionId_;
 }
@@ -70,3 +61,12 @@ void DeleteVpdGrantRuleRequest::setRegionId(const std::string &regionId) {
   setBodyParameter(std::string("RegionId"), regionId);
 }
 
+std::string DeleteVpdGrantRuleRequest::getGrantRuleId() const {
+  return grantRuleId_;
+}
+
+void DeleteVpdGrantRuleRequest::setGrantRuleId(const std::string &grantRuleId) {
+  grantRuleId_ = grantRuleId;
+  setBodyParameter(std::string("GrantRuleId"), grantRuleId);
+}
+

eflo/src/model/GetElasticNetworkInterfaceResult.cc

@@ -72,6 +72,8 @@ void GetElasticNetworkInterfaceResult::parse(const std::string &payload)
 		content_.gmtModified = contentNode["GmtModified"].asString();
 	if(!contentNode["Description"].isNull())
 		content_.description = contentNode["Description"].asString();
+	if(!contentNode["SecurityGroupId"].isNull())
+		content_.securityGroupId = contentNode["SecurityGroupId"].asString();
 	auto allPrivateIpAddressesNode = contentNode["PrivateIpAddresses"]["PrivateIpAddress"];
 	for (auto contentNodePrivateIpAddressesPrivateIpAddress : allPrivateIpAddressesNode)
 	{

eflo/src/model/GetLeniPrivateIpAddressRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/GetLeniPrivateIpAddressRequest.h>
+
+using AlibabaCloud::Eflo::Model::GetLeniPrivateIpAddressRequest;
+
+GetLeniPrivateIpAddressRequest::GetLeniPrivateIpAddressRequest()
+    : RpcServiceRequest("eflo", "2022-05-30", "GetLeniPrivateIpAddress") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetLeniPrivateIpAddressRequest::~GetLeniPrivateIpAddressRequest() {}
+
+std::string GetLeniPrivateIpAddressRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetLeniPrivateIpAddressRequest::getIpName() const {
+  return ipName_;
+}
+
+void GetLeniPrivateIpAddressRequest::setIpName(const std::string &ipName) {
+  ipName_ = ipName;
+  setBodyParameter(std::string("IpName"), ipName);
+}
+
+std::string GetLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
+  return elasticNetworkInterfaceId_;
+}
+
+void GetLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
+  elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
+  setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
+}
+

eflo/src/model/GetLeniPrivateIpAddressResult.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/GetLeniPrivateIpAddressResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Eflo;
+using namespace AlibabaCloud::Eflo::Model;
+
+GetLeniPrivateIpAddressResult::GetLeniPrivateIpAddressResult() :
+	ServiceResult()
+{}
+
+GetLeniPrivateIpAddressResult::GetLeniPrivateIpAddressResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetLeniPrivateIpAddressResult::~GetLeniPrivateIpAddressResult()
+{}
+
+void GetLeniPrivateIpAddressResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto contentNode = value["Content"];
+	if(!contentNode["ElasticNetworkInterfaceId"].isNull())
+		content_.elasticNetworkInterfaceId = contentNode["ElasticNetworkInterfaceId"].asString();
+	if(!contentNode["RegionId"].isNull())
+		content_.regionId = contentNode["RegionId"].asString();
+	if(!contentNode["GmtCreate"].isNull())
+		content_.gmtCreate = contentNode["GmtCreate"].asString();
+	if(!contentNode["GmtModified"].isNull())
+		content_.gmtModified = contentNode["GmtModified"].asString();
+	if(!contentNode["IpName"].isNull())
+		content_.ipName = contentNode["IpName"].asString();
+	if(!contentNode["PrivateIpAddress"].isNull())
+		content_.privateIpAddress = contentNode["PrivateIpAddress"].asString();
+	if(!contentNode["Status"].isNull())
+		content_.status = contentNode["Status"].asString();
+	if(!contentNode["Description"].isNull())
+		content_.description = contentNode["Description"].asString();
+	if(!contentNode["Message"].isNull())
+		content_.message = contentNode["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetLeniPrivateIpAddressResult::getMessage()const
+{
+	return message_;
+}
+
+GetLeniPrivateIpAddressResult::Content GetLeniPrivateIpAddressResult::getContent()const
+{
+	return content_;
+}
+
+int GetLeniPrivateIpAddressResult::getCode()const
+{
+	return code_;
+}
+

eflo/src/model/GetNodeInfoForPodResult.cc

@@ -54,6 +54,8 @@ void GetNodeInfoForPodResult::parse(const std::string &payload)
 		content_.leniQuota = std::stoi(contentNode["LeniQuota"].asString());
 	if(!contentNode["LniSipQuota"].isNull())
 		content_.lniSipQuota = std::stoi(contentNode["LniSipQuota"].asString());
+	if(!contentNode["HdeniQuota"].isNull())
+		content_.hdeniQuota = std::stoi(contentNode["HdeniQuota"].asString());
 		auto allVSwitches = contentNode["VSwitches"]["VSwitche"];
 		for (auto value : allVSwitches)
 			content_.vSwitches.push_back(value.asString());

eflo/src/model/GetVccGrantRuleResult.cc

@@ -60,6 +60,8 @@ void GetVccGrantRuleResult::parse(const std::string &payload)
 		content_.createTime = contentNode["CreateTime"].asString();
 	if(!contentNode["GrantRuleId"].isNull())
 		content_.grantRuleId = contentNode["GrantRuleId"].asString();
+	if(!contentNode["ResourceGroupId"].isNull())
+		content_.resourceGroupId = contentNode["ResourceGroupId"].asString();
 	if(!value["Code"].isNull())
 		code_ = std::stoi(value["Code"].asString());
 	if(!value["Message"].isNull())

eflo/src/model/GetVccRequest.cc

@@ -25,6 +25,15 @@ GetVccRequest::GetVccRequest()
 
 GetVccRequest::~GetVccRequest() {}
 
+std::string GetVccRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void GetVccRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setBodyParameter(std::string("ClientToken"), clientToken);
+}
+
 int GetVccRequest::getPageNumber() const {
   return pageNumber_;
 }

eflo/src/model/GetVccResult.cc

@@ -184,6 +184,38 @@ void GetVccResult::parse(const std::string &payload)
 			tagObject.tagValue = contentNodeTagsTag["TagValue"].asString();
 		content_.tags.push_back(tagObject);
 	}
+	auto allVbrInfosNode = contentNode["VbrInfos"]["VbrInfo"];
+	for (auto contentNodeVbrInfosVbrInfo : allVbrInfosNode)
+	{
+		Content::VbrInfo vbrInfoObject;
+		if(!contentNodeVbrInfosVbrInfo["VbrId"].isNull())
+			vbrInfoObject.vbrId = contentNodeVbrInfosVbrInfo["VbrId"].asString();
+		if(!contentNodeVbrInfosVbrInfo["CenId"].isNull())
+			vbrInfoObject.cenId = contentNodeVbrInfosVbrInfo["CenId"].asString();
+		if(!contentNodeVbrInfosVbrInfo["Status"].isNull())
+			vbrInfoObject.status = contentNodeVbrInfosVbrInfo["Status"].asString();
+		if(!contentNodeVbrInfosVbrInfo["GmtCreate"].isNull())
+			vbrInfoObject.gmtCreate = contentNodeVbrInfosVbrInfo["GmtCreate"].asString();
+		if(!contentNodeVbrInfosVbrInfo["GmtModified"].isNull())
+			vbrInfoObject.gmtModified = contentNodeVbrInfosVbrInfo["GmtModified"].asString();
+		auto allVbrBgpPeersNode = contentNodeVbrInfosVbrInfo["VbrBgpPeers"]["VbrBgpPeer"];
+		for (auto contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer : allVbrBgpPeersNode)
+		{
+			Content::VbrInfo::VbrBgpPeer vbrBgpPeersObject;
+			if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpGroupId"].isNull())
+				vbrBgpPeersObject.bgpGroupId = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpGroupId"].asString();
+			if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpPeerId"].isNull())
+				vbrBgpPeersObject.bgpPeerId = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["BgpPeerId"].asString();
+			if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerIpAddress"].isNull())
+				vbrBgpPeersObject.peerIpAddress = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerIpAddress"].asString();
+			if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerAsn"].isNull())
+				vbrBgpPeersObject.peerAsn = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["PeerAsn"].asString();
+			if(!contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["Status"].isNull())
+				vbrBgpPeersObject.status = contentNodeVbrInfosVbrInfoVbrBgpPeersVbrBgpPeer["Status"].asString();
+			vbrInfoObject.vbrBgpPeers.push_back(vbrBgpPeersObject);
+		}
+		content_.vbrInfos.push_back(vbrInfoObject);
+	}
 	auto vpdBaseInfoNode = contentNode["VpdBaseInfo"];
 	if(!vpdBaseInfoNode["VpdId"].isNull())
 		content_.vpdBaseInfo.vpdId = vpdBaseInfoNode["VpdId"].asString();

eflo/src/model/GetVccRouteEntryResult.cc

@@ -60,6 +60,8 @@ void GetVccRouteEntryResult::parse(const std::string &payload)
 		content_.status = contentNode["Status"].asString();
 	if(!contentNode["GmtModified"].isNull())
 		content_.gmtModified = contentNode["GmtModified"].asString();
+	if(!contentNode["Message"].isNull())
+		content_.message = contentNode["Message"].asString();
 	if(!value["Code"].isNull())
 		code_ = std::stoi(value["Code"].asString());
 	if(!value["Message"].isNull())

eflo/src/model/GetVpdGrantRuleResult.cc

@@ -60,6 +60,8 @@ void GetVpdGrantRuleResult::parse(const std::string &payload)
 		content_.createTime = contentNode["CreateTime"].asString();
 	if(!contentNode["GrantRuleId"].isNull())
 		content_.grantRuleId = contentNode["GrantRuleId"].asString();
+	if(!contentNode["ResourceGroupId"].isNull())
+		content_.resourceGroupId = contentNode["ResourceGroupId"].asString();
 	if(!value["Code"].isNull())
 		code_ = std::stoi(value["Code"].asString());
 	if(!value["Message"].isNull())

eflo/src/model/ListElasticNetworkInterfacesResult.cc

@@ -78,6 +78,8 @@ void ListElasticNetworkInterfacesResult::parse(const std::string &payload)
 			dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
 		if(!contentNodeDataDataItem["Description"].isNull())
 			dataItemObject.description = contentNodeDataDataItem["Description"].asString();
+		if(!contentNodeDataDataItem["SecurityGroupId"].isNull())
+			dataItemObject.securityGroupId = contentNodeDataDataItem["SecurityGroupId"].asString();
 		content_.data.push_back(dataItemObject);
 	}
 	if(!value["Code"].isNull())

eflo/src/model/ListLeniPrivateIpAddressesRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/ListLeniPrivateIpAddressesRequest.h>
+
+using AlibabaCloud::Eflo::Model::ListLeniPrivateIpAddressesRequest;
+
+ListLeniPrivateIpAddressesRequest::ListLeniPrivateIpAddressesRequest()
+    : RpcServiceRequest("eflo", "2022-05-30", "ListLeniPrivateIpAddresses") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListLeniPrivateIpAddressesRequest::~ListLeniPrivateIpAddressesRequest() {}
+
+int ListLeniPrivateIpAddressesRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string ListLeniPrivateIpAddressesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+int ListLeniPrivateIpAddressesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListLeniPrivateIpAddressesRequest::getPrivateIpAddress() const {
+  return privateIpAddress_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setPrivateIpAddress(const std::string &privateIpAddress) {
+  privateIpAddress_ = privateIpAddress;
+  setBodyParameter(std::string("PrivateIpAddress"), privateIpAddress);
+}
+
+std::string ListLeniPrivateIpAddressesRequest::getIpName() const {
+  return ipName_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setIpName(const std::string &ipName) {
+  ipName_ = ipName;
+  setBodyParameter(std::string("IpName"), ipName);
+}
+
+std::string ListLeniPrivateIpAddressesRequest::getElasticNetworkInterfaceId() const {
+  return elasticNetworkInterfaceId_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
+  elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
+  setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
+}
+
+std::string ListLeniPrivateIpAddressesRequest::getStatus() const {
+  return status_;
+}
+
+void ListLeniPrivateIpAddressesRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setBodyParameter(std::string("Status"), status);
+}
+

eflo/src/model/ListLeniPrivateIpAddressesResult.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/ListLeniPrivateIpAddressesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Eflo;
+using namespace AlibabaCloud::Eflo::Model;
+
+ListLeniPrivateIpAddressesResult::ListLeniPrivateIpAddressesResult() :
+	ServiceResult()
+{}
+
+ListLeniPrivateIpAddressesResult::ListLeniPrivateIpAddressesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListLeniPrivateIpAddressesResult::~ListLeniPrivateIpAddressesResult()
+{}
+
+void ListLeniPrivateIpAddressesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto contentNode = value["Content"];
+	if(!contentNode["Total"].isNull())
+		content_.total = std::stol(contentNode["Total"].asString());
+	auto allDataNode = contentNode["Data"]["DataItem"];
+	for (auto contentNodeDataDataItem : allDataNode)
+	{
+		Content::DataItem dataItemObject;
+		if(!contentNodeDataDataItem["ElasticNetworkInterfaceId"].isNull())
+			dataItemObject.elasticNetworkInterfaceId = contentNodeDataDataItem["ElasticNetworkInterfaceId"].asString();
+		if(!contentNodeDataDataItem["RegionId"].isNull())
+			dataItemObject.regionId = contentNodeDataDataItem["RegionId"].asString();
+		if(!contentNodeDataDataItem["GmtCreate"].isNull())
+			dataItemObject.gmtCreate = contentNodeDataDataItem["GmtCreate"].asString();
+		if(!contentNodeDataDataItem["GmtModified"].isNull())
+			dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
+		if(!contentNodeDataDataItem["IpName"].isNull())
+			dataItemObject.ipName = contentNodeDataDataItem["IpName"].asString();
+		if(!contentNodeDataDataItem["PrivateIpAddress"].isNull())
+			dataItemObject.privateIpAddress = contentNodeDataDataItem["PrivateIpAddress"].asString();
+		if(!contentNodeDataDataItem["Status"].isNull())
+			dataItemObject.status = contentNodeDataDataItem["Status"].asString();
+		if(!contentNodeDataDataItem["Description"].isNull())
+			dataItemObject.description = contentNodeDataDataItem["Description"].asString();
+		if(!contentNodeDataDataItem["Message"].isNull())
+			dataItemObject.message = contentNodeDataDataItem["Message"].asString();
+		content_.data.push_back(dataItemObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListLeniPrivateIpAddressesResult::getMessage()const
+{
+	return message_;
+}
+
+ListLeniPrivateIpAddressesResult::Content ListLeniPrivateIpAddressesResult::getContent()const
+{
+	return content_;
+}
+
+int ListLeniPrivateIpAddressesResult::getCode()const
+{
+	return code_;
+}
+

eflo/src/model/ListVccGrantRulesRequest.cc

@@ -43,6 +43,15 @@ void ListVccGrantRulesRequest::setPageNumber(int pageNumber) {
   setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string ListVccGrantRulesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ListVccGrantRulesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string ListVccGrantRulesRequest::getRegionId() const {
   return regionId_;
 }

eflo/src/model/ListVccGrantRulesResult.cc

@@ -66,6 +66,8 @@ void ListVccGrantRulesResult::parse(const std::string &payload)
 			dataItemObject.createTime = contentNodeDataDataItem["CreateTime"].asString();
 		if(!contentNodeDataDataItem["GrantRuleId"].isNull())
 			dataItemObject.grantRuleId = contentNodeDataDataItem["GrantRuleId"].asString();
+		if(!contentNodeDataDataItem["ResourceGroupId"].isNull())
+			dataItemObject.resourceGroupId = contentNodeDataDataItem["ResourceGroupId"].asString();
 		content_.data.push_back(dataItemObject);
 	}
 	if(!value["Code"].isNull())

eflo/src/model/ListVccRouteEntriesResult.cc

@@ -68,6 +68,8 @@ void ListVccRouteEntriesResult::parse(const std::string &payload)
 			dataItemObject.status = contentNodeDataDataItem["Status"].asString();
 		if(!contentNodeDataDataItem["GmtModified"].isNull())
 			dataItemObject.gmtModified = contentNodeDataDataItem["GmtModified"].asString();
+		if(!contentNodeDataDataItem["Message"].isNull())
+			dataItemObject.message = contentNodeDataDataItem["Message"].asString();
 		content_.data.push_back(dataItemObject);
 	}
 	if(!value["Code"].isNull())

eflo/src/model/ListVpdGrantRulesRequest.cc

@@ -43,6 +43,15 @@ void ListVpdGrantRulesRequest::setPageNumber(int pageNumber) {
   setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
+std::string ListVpdGrantRulesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ListVpdGrantRulesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
 std::string ListVpdGrantRulesRequest::getRegionId() const {
   return regionId_;
 }

eflo/src/model/ListVpdGrantRulesResult.cc

@@ -66,6 +66,8 @@ void ListVpdGrantRulesResult::parse(const std::string &payload)
 			dataItemObject.createTime = contentNodeDataDataItem["CreateTime"].asString();
 		if(!contentNodeDataDataItem["GrantRuleId"].isNull())
 			dataItemObject.grantRuleId = contentNodeDataDataItem["GrantRuleId"].asString();
+		if(!contentNodeDataDataItem["ResourceGroupId"].isNull())
+			dataItemObject.resourceGroupId = contentNodeDataDataItem["ResourceGroupId"].asString();
 		content_.data.push_back(dataItemObject);
 	}
 	if(!value["Code"].isNull())

eflo/src/model/UnassignLeniPrivateIpAddressRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/UnassignLeniPrivateIpAddressRequest.h>
+
+using AlibabaCloud::Eflo::Model::UnassignLeniPrivateIpAddressRequest;
+
+UnassignLeniPrivateIpAddressRequest::UnassignLeniPrivateIpAddressRequest()
+    : RpcServiceRequest("eflo", "2022-05-30", "UnassignLeniPrivateIpAddress") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UnassignLeniPrivateIpAddressRequest::~UnassignLeniPrivateIpAddressRequest() {}
+
+std::string UnassignLeniPrivateIpAddressRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void UnassignLeniPrivateIpAddressRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setBodyParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string UnassignLeniPrivateIpAddressRequest::getRegionId() const {
+  return regionId_;
+}
+
+void UnassignLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string UnassignLeniPrivateIpAddressRequest::getIpName() const {
+  return ipName_;
+}
+
+void UnassignLeniPrivateIpAddressRequest::setIpName(const std::string &ipName) {
+  ipName_ = ipName;
+  setBodyParameter(std::string("IpName"), ipName);
+}
+
+std::string UnassignLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
+  return elasticNetworkInterfaceId_;
+}
+
+void UnassignLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
+  elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
+  setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
+}
+

eflo/src/model/UnassignLeniPrivateIpAddressResult.cc

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

eflo/src/model/UpdateLeniPrivateIpAddressRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/eflo/model/UpdateLeniPrivateIpAddressRequest.h>
+
+using AlibabaCloud::Eflo::Model::UpdateLeniPrivateIpAddressRequest;
+
+UpdateLeniPrivateIpAddressRequest::UpdateLeniPrivateIpAddressRequest()
+    : RpcServiceRequest("eflo", "2022-05-30", "UpdateLeniPrivateIpAddress") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateLeniPrivateIpAddressRequest::~UpdateLeniPrivateIpAddressRequest() {}
+
+std::string UpdateLeniPrivateIpAddressRequest::getDescription() const {
+  return description_;
+}
+
+void UpdateLeniPrivateIpAddressRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string UpdateLeniPrivateIpAddressRequest::getRegionId() const {
+  return regionId_;
+}
+
+void UpdateLeniPrivateIpAddressRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setBodyParameter(std::string("RegionId"), regionId);
+}
+
+std::string UpdateLeniPrivateIpAddressRequest::getIpName() const {
+  return ipName_;
+}
+
+void UpdateLeniPrivateIpAddressRequest::setIpName(const std::string &ipName) {
+  ipName_ = ipName;
+  setBodyParameter(std::string("IpName"), ipName);
+}
+
+std::string UpdateLeniPrivateIpAddressRequest::getElasticNetworkInterfaceId() const {
+  return elasticNetworkInterfaceId_;
+}
+
+void UpdateLeniPrivateIpAddressRequest::setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId) {
+  elasticNetworkInterfaceId_ = elasticNetworkInterfaceId;
+  setBodyParameter(std::string("ElasticNetworkInterfaceId"), elasticNetworkInterfaceId);
+}
+

eflo/src/model/UpdateLeniPrivateIpAddressResult.cc

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