Support elastic network interface.

VERSION

@@ -1 +1 @@
-1.36.1737
+1.36.1738

eflo/CMakeLists.txt

@@ -21,30 +21,126 @@ set(eflo_public_header
 	include/alibabacloud/eflo/EfloExport.h )
 
 set(eflo_public_header_model 
+	include/alibabacloud/eflo/model/AssignPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/AssignPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/AssociateVpdCidrBlockRequest.h
+	include/alibabacloud/eflo/model/AssociateVpdCidrBlockResult.h
+	include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/CreateErRequest.h
+	include/alibabacloud/eflo/model/CreateErResult.h
+	include/alibabacloud/eflo/model/CreateErAttachmentRequest.h
+	include/alibabacloud/eflo/model/CreateErAttachmentResult.h
+	include/alibabacloud/eflo/model/CreateErRouteMapRequest.h
+	include/alibabacloud/eflo/model/CreateErRouteMapResult.h
 	include/alibabacloud/eflo/model/CreateSubnetRequest.h
 	include/alibabacloud/eflo/model/CreateSubnetResult.h
 	include/alibabacloud/eflo/model/CreateVccRequest.h
 	include/alibabacloud/eflo/model/CreateVccResult.h
+	include/alibabacloud/eflo/model/CreateVccGrantRuleRequest.h
+	include/alibabacloud/eflo/model/CreateVccGrantRuleResult.h
+	include/alibabacloud/eflo/model/CreateVccRouteEntryRequest.h
+	include/alibabacloud/eflo/model/CreateVccRouteEntryResult.h
 	include/alibabacloud/eflo/model/CreateVpdRequest.h
 	include/alibabacloud/eflo/model/CreateVpdResult.h
+	include/alibabacloud/eflo/model/CreateVpdGrantRuleRequest.h
+	include/alibabacloud/eflo/model/CreateVpdGrantRuleResult.h
+	include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/DeleteErRequest.h
+	include/alibabacloud/eflo/model/DeleteErResult.h
+	include/alibabacloud/eflo/model/DeleteErAttachmentRequest.h
+	include/alibabacloud/eflo/model/DeleteErAttachmentResult.h
+	include/alibabacloud/eflo/model/DeleteErRouteMapRequest.h
+	include/alibabacloud/eflo/model/DeleteErRouteMapResult.h
 	include/alibabacloud/eflo/model/DeleteSubnetRequest.h
 	include/alibabacloud/eflo/model/DeleteSubnetResult.h
+	include/alibabacloud/eflo/model/DeleteVccGrantRuleRequest.h
+	include/alibabacloud/eflo/model/DeleteVccGrantRuleResult.h
+	include/alibabacloud/eflo/model/DeleteVccRouteEntryRequest.h
+	include/alibabacloud/eflo/model/DeleteVccRouteEntryResult.h
 	include/alibabacloud/eflo/model/DeleteVpdRequest.h
 	include/alibabacloud/eflo/model/DeleteVpdResult.h
+	include/alibabacloud/eflo/model/DeleteVpdGrantRuleRequest.h
+	include/alibabacloud/eflo/model/DeleteVpdGrantRuleResult.h
+	include/alibabacloud/eflo/model/DescribeSlrRequest.h
+	include/alibabacloud/eflo/model/DescribeSlrResult.h
+	include/alibabacloud/eflo/model/GetElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/GetElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/GetErRequest.h
+	include/alibabacloud/eflo/model/GetErResult.h
+	include/alibabacloud/eflo/model/GetErAttachmentRequest.h
+	include/alibabacloud/eflo/model/GetErAttachmentResult.h
+	include/alibabacloud/eflo/model/GetErRouteEntryRequest.h
+	include/alibabacloud/eflo/model/GetErRouteEntryResult.h
+	include/alibabacloud/eflo/model/GetErRouteMapRequest.h
+	include/alibabacloud/eflo/model/GetErRouteMapResult.h
+	include/alibabacloud/eflo/model/GetFabricTopologyRequest.h
+	include/alibabacloud/eflo/model/GetFabricTopologyResult.h
+	include/alibabacloud/eflo/model/GetLniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/GetLniPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/GetNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/GetNetworkInterfaceResult.h
 	include/alibabacloud/eflo/model/GetSubnetRequest.h
 	include/alibabacloud/eflo/model/GetSubnetResult.h
 	include/alibabacloud/eflo/model/GetVccRequest.h
 	include/alibabacloud/eflo/model/GetVccResult.h
+	include/alibabacloud/eflo/model/GetVccGrantRuleRequest.h
+	include/alibabacloud/eflo/model/GetVccGrantRuleResult.h
+	include/alibabacloud/eflo/model/GetVccRouteEntryRequest.h
+	include/alibabacloud/eflo/model/GetVccRouteEntryResult.h
 	include/alibabacloud/eflo/model/GetVpdRequest.h
 	include/alibabacloud/eflo/model/GetVpdResult.h
+	include/alibabacloud/eflo/model/GetVpdGrantRuleRequest.h
+	include/alibabacloud/eflo/model/GetVpdGrantRuleResult.h
+	include/alibabacloud/eflo/model/GetVpdRouteEntryRequest.h
+	include/alibabacloud/eflo/model/GetVpdRouteEntryResult.h
 	include/alibabacloud/eflo/model/InitializeVccRequest.h
 	include/alibabacloud/eflo/model/InitializeVccResult.h
+	include/alibabacloud/eflo/model/ListElasticNetworkInterfacesRequest.h
+	include/alibabacloud/eflo/model/ListElasticNetworkInterfacesResult.h
+	include/alibabacloud/eflo/model/ListErAttachmentsRequest.h
+	include/alibabacloud/eflo/model/ListErAttachmentsResult.h
+	include/alibabacloud/eflo/model/ListErRouteEntriesRequest.h
+	include/alibabacloud/eflo/model/ListErRouteEntriesResult.h
+	include/alibabacloud/eflo/model/ListErRouteMapsRequest.h
+	include/alibabacloud/eflo/model/ListErRouteMapsResult.h
+	include/alibabacloud/eflo/model/ListErsRequest.h
+	include/alibabacloud/eflo/model/ListErsResult.h
+	include/alibabacloud/eflo/model/ListInstancesByNcdRequest.h
+	include/alibabacloud/eflo/model/ListInstancesByNcdResult.h
+	include/alibabacloud/eflo/model/ListLniPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/ListLniPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/ListNetworkInterfacesRequest.h
+	include/alibabacloud/eflo/model/ListNetworkInterfacesResult.h
 	include/alibabacloud/eflo/model/ListSubnetsRequest.h
 	include/alibabacloud/eflo/model/ListSubnetsResult.h
+	include/alibabacloud/eflo/model/ListVccGrantRulesRequest.h
+	include/alibabacloud/eflo/model/ListVccGrantRulesResult.h
+	include/alibabacloud/eflo/model/ListVccRouteEntriesRequest.h
+	include/alibabacloud/eflo/model/ListVccRouteEntriesResult.h
 	include/alibabacloud/eflo/model/ListVccsRequest.h
 	include/alibabacloud/eflo/model/ListVccsResult.h
+	include/alibabacloud/eflo/model/ListVpdGrantRulesRequest.h
+	include/alibabacloud/eflo/model/ListVpdGrantRulesResult.h
+	include/alibabacloud/eflo/model/ListVpdRouteEntriesRequest.h
+	include/alibabacloud/eflo/model/ListVpdRouteEntriesResult.h
 	include/alibabacloud/eflo/model/ListVpdsRequest.h
 	include/alibabacloud/eflo/model/ListVpdsResult.h
+	include/alibabacloud/eflo/model/QueryInstanceNcdRequest.h
+	include/alibabacloud/eflo/model/QueryInstanceNcdResult.h
+	include/alibabacloud/eflo/model/UnAssignPrivateIpAddressRequest.h
+	include/alibabacloud/eflo/model/UnAssignPrivateIpAddressResult.h
+	include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockRequest.h
+	include/alibabacloud/eflo/model/UnAssociateVpdCidrBlockResult.h
+	include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceRequest.h
+	include/alibabacloud/eflo/model/UpdateElasticNetworkInterfaceResult.h
+	include/alibabacloud/eflo/model/UpdateErRequest.h
+	include/alibabacloud/eflo/model/UpdateErResult.h
+	include/alibabacloud/eflo/model/UpdateErAttachmentRequest.h
+	include/alibabacloud/eflo/model/UpdateErAttachmentResult.h
+	include/alibabacloud/eflo/model/UpdateErRouteMapRequest.h
+	include/alibabacloud/eflo/model/UpdateErRouteMapResult.h
 	include/alibabacloud/eflo/model/UpdateSubnetRequest.h
 	include/alibabacloud/eflo/model/UpdateSubnetResult.h
 	include/alibabacloud/eflo/model/UpdateVccRequest.h
@@ -54,30 +150,126 @@ set(eflo_public_header_model
 
 set(eflo_src 
 	src/EfloClient.cc
+	src/model/AssignPrivateIpAddressRequest.cc
+	src/model/AssignPrivateIpAddressResult.cc
+	src/model/AssociateVpdCidrBlockRequest.cc
+	src/model/AssociateVpdCidrBlockResult.cc
+	src/model/CreateElasticNetworkInterfaceRequest.cc
+	src/model/CreateElasticNetworkInterfaceResult.cc
+	src/model/CreateErRequest.cc
+	src/model/CreateErResult.cc
+	src/model/CreateErAttachmentRequest.cc
+	src/model/CreateErAttachmentResult.cc
+	src/model/CreateErRouteMapRequest.cc
+	src/model/CreateErRouteMapResult.cc
 	src/model/CreateSubnetRequest.cc
 	src/model/CreateSubnetResult.cc
 	src/model/CreateVccRequest.cc
 	src/model/CreateVccResult.cc
+	src/model/CreateVccGrantRuleRequest.cc
+	src/model/CreateVccGrantRuleResult.cc
+	src/model/CreateVccRouteEntryRequest.cc
+	src/model/CreateVccRouteEntryResult.cc
 	src/model/CreateVpdRequest.cc
 	src/model/CreateVpdResult.cc
+	src/model/CreateVpdGrantRuleRequest.cc
+	src/model/CreateVpdGrantRuleResult.cc
+	src/model/DeleteElasticNetworkInterfaceRequest.cc
+	src/model/DeleteElasticNetworkInterfaceResult.cc
+	src/model/DeleteErRequest.cc
+	src/model/DeleteErResult.cc
+	src/model/DeleteErAttachmentRequest.cc
+	src/model/DeleteErAttachmentResult.cc
+	src/model/DeleteErRouteMapRequest.cc
+	src/model/DeleteErRouteMapResult.cc
 	src/model/DeleteSubnetRequest.cc
 	src/model/DeleteSubnetResult.cc
+	src/model/DeleteVccGrantRuleRequest.cc
+	src/model/DeleteVccGrantRuleResult.cc
+	src/model/DeleteVccRouteEntryRequest.cc
+	src/model/DeleteVccRouteEntryResult.cc
 	src/model/DeleteVpdRequest.cc
 	src/model/DeleteVpdResult.cc
+	src/model/DeleteVpdGrantRuleRequest.cc
+	src/model/DeleteVpdGrantRuleResult.cc
+	src/model/DescribeSlrRequest.cc
+	src/model/DescribeSlrResult.cc
+	src/model/GetElasticNetworkInterfaceRequest.cc
+	src/model/GetElasticNetworkInterfaceResult.cc
+	src/model/GetErRequest.cc
+	src/model/GetErResult.cc
+	src/model/GetErAttachmentRequest.cc
+	src/model/GetErAttachmentResult.cc
+	src/model/GetErRouteEntryRequest.cc
+	src/model/GetErRouteEntryResult.cc
+	src/model/GetErRouteMapRequest.cc
+	src/model/GetErRouteMapResult.cc
+	src/model/GetFabricTopologyRequest.cc
+	src/model/GetFabricTopologyResult.cc
+	src/model/GetLniPrivateIpAddressRequest.cc
+	src/model/GetLniPrivateIpAddressResult.cc
+	src/model/GetNetworkInterfaceRequest.cc
+	src/model/GetNetworkInterfaceResult.cc
 	src/model/GetSubnetRequest.cc
 	src/model/GetSubnetResult.cc
 	src/model/GetVccRequest.cc
 	src/model/GetVccResult.cc
+	src/model/GetVccGrantRuleRequest.cc
+	src/model/GetVccGrantRuleResult.cc
+	src/model/GetVccRouteEntryRequest.cc
+	src/model/GetVccRouteEntryResult.cc
 	src/model/GetVpdRequest.cc
 	src/model/GetVpdResult.cc
+	src/model/GetVpdGrantRuleRequest.cc
+	src/model/GetVpdGrantRuleResult.cc
+	src/model/GetVpdRouteEntryRequest.cc
+	src/model/GetVpdRouteEntryResult.cc
 	src/model/InitializeVccRequest.cc
 	src/model/InitializeVccResult.cc
+	src/model/ListElasticNetworkInterfacesRequest.cc
+	src/model/ListElasticNetworkInterfacesResult.cc
+	src/model/ListErAttachmentsRequest.cc
+	src/model/ListErAttachmentsResult.cc
+	src/model/ListErRouteEntriesRequest.cc
+	src/model/ListErRouteEntriesResult.cc
+	src/model/ListErRouteMapsRequest.cc
+	src/model/ListErRouteMapsResult.cc
+	src/model/ListErsRequest.cc
+	src/model/ListErsResult.cc
+	src/model/ListInstancesByNcdRequest.cc
+	src/model/ListInstancesByNcdResult.cc
+	src/model/ListLniPrivateIpAddressRequest.cc
+	src/model/ListLniPrivateIpAddressResult.cc
+	src/model/ListNetworkInterfacesRequest.cc
+	src/model/ListNetworkInterfacesResult.cc
 	src/model/ListSubnetsRequest.cc
 	src/model/ListSubnetsResult.cc
+	src/model/ListVccGrantRulesRequest.cc
+	src/model/ListVccGrantRulesResult.cc
+	src/model/ListVccRouteEntriesRequest.cc
+	src/model/ListVccRouteEntriesResult.cc
 	src/model/ListVccsRequest.cc
 	src/model/ListVccsResult.cc
+	src/model/ListVpdGrantRulesRequest.cc
+	src/model/ListVpdGrantRulesResult.cc
+	src/model/ListVpdRouteEntriesRequest.cc
+	src/model/ListVpdRouteEntriesResult.cc
 	src/model/ListVpdsRequest.cc
 	src/model/ListVpdsResult.cc
+	src/model/QueryInstanceNcdRequest.cc
+	src/model/QueryInstanceNcdResult.cc
+	src/model/UnAssignPrivateIpAddressRequest.cc
+	src/model/UnAssignPrivateIpAddressResult.cc
+	src/model/UnAssociateVpdCidrBlockRequest.cc
+	src/model/UnAssociateVpdCidrBlockResult.cc
+	src/model/UpdateElasticNetworkInterfaceRequest.cc
+	src/model/UpdateElasticNetworkInterfaceResult.cc
+	src/model/UpdateErRequest.cc
+	src/model/UpdateErResult.cc
+	src/model/UpdateErAttachmentRequest.cc
+	src/model/UpdateErAttachmentResult.cc
+	src/model/UpdateErRouteMapRequest.cc
+	src/model/UpdateErRouteMapResult.cc
 	src/model/UpdateSubnetRequest.cc
 	src/model/UpdateSubnetResult.cc
 	src/model/UpdateVccRequest.cc

eflo/include/alibabacloud/eflo/EfloClient.h

@@ -22,30 +22,126 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "EfloExport.h"
+#include "model/AssignPrivateIpAddressRequest.h"
+#include "model/AssignPrivateIpAddressResult.h"
+#include "model/AssociateVpdCidrBlockRequest.h"
+#include "model/AssociateVpdCidrBlockResult.h"
+#include "model/CreateElasticNetworkInterfaceRequest.h"
+#include "model/CreateElasticNetworkInterfaceResult.h"
+#include "model/CreateErRequest.h"
+#include "model/CreateErResult.h"
+#include "model/CreateErAttachmentRequest.h"
+#include "model/CreateErAttachmentResult.h"
+#include "model/CreateErRouteMapRequest.h"
+#include "model/CreateErRouteMapResult.h"
 #include "model/CreateSubnetRequest.h"
 #include "model/CreateSubnetResult.h"
 #include "model/CreateVccRequest.h"
 #include "model/CreateVccResult.h"
+#include "model/CreateVccGrantRuleRequest.h"
+#include "model/CreateVccGrantRuleResult.h"
+#include "model/CreateVccRouteEntryRequest.h"
+#include "model/CreateVccRouteEntryResult.h"
 #include "model/CreateVpdRequest.h"
 #include "model/CreateVpdResult.h"
+#include "model/CreateVpdGrantRuleRequest.h"
+#include "model/CreateVpdGrantRuleResult.h"
+#include "model/DeleteElasticNetworkInterfaceRequest.h"
+#include "model/DeleteElasticNetworkInterfaceResult.h"
+#include "model/DeleteErRequest.h"
+#include "model/DeleteErResult.h"
+#include "model/DeleteErAttachmentRequest.h"
+#include "model/DeleteErAttachmentResult.h"
+#include "model/DeleteErRouteMapRequest.h"
+#include "model/DeleteErRouteMapResult.h"
 #include "model/DeleteSubnetRequest.h"
 #include "model/DeleteSubnetResult.h"
+#include "model/DeleteVccGrantRuleRequest.h"
+#include "model/DeleteVccGrantRuleResult.h"
+#include "model/DeleteVccRouteEntryRequest.h"
+#include "model/DeleteVccRouteEntryResult.h"
 #include "model/DeleteVpdRequest.h"
 #include "model/DeleteVpdResult.h"
+#include "model/DeleteVpdGrantRuleRequest.h"
+#include "model/DeleteVpdGrantRuleResult.h"
+#include "model/DescribeSlrRequest.h"
+#include "model/DescribeSlrResult.h"
+#include "model/GetElasticNetworkInterfaceRequest.h"
+#include "model/GetElasticNetworkInterfaceResult.h"
+#include "model/GetErRequest.h"
+#include "model/GetErResult.h"
+#include "model/GetErAttachmentRequest.h"
+#include "model/GetErAttachmentResult.h"
+#include "model/GetErRouteEntryRequest.h"
+#include "model/GetErRouteEntryResult.h"
+#include "model/GetErRouteMapRequest.h"
+#include "model/GetErRouteMapResult.h"
+#include "model/GetFabricTopologyRequest.h"
+#include "model/GetFabricTopologyResult.h"
+#include "model/GetLniPrivateIpAddressRequest.h"
+#include "model/GetLniPrivateIpAddressResult.h"
+#include "model/GetNetworkInterfaceRequest.h"
+#include "model/GetNetworkInterfaceResult.h"
 #include "model/GetSubnetRequest.h"
 #include "model/GetSubnetResult.h"
 #include "model/GetVccRequest.h"
 #include "model/GetVccResult.h"
+#include "model/GetVccGrantRuleRequest.h"
+#include "model/GetVccGrantRuleResult.h"
+#include "model/GetVccRouteEntryRequest.h"
+#include "model/GetVccRouteEntryResult.h"
 #include "model/GetVpdRequest.h"
 #include "model/GetVpdResult.h"
+#include "model/GetVpdGrantRuleRequest.h"
+#include "model/GetVpdGrantRuleResult.h"
+#include "model/GetVpdRouteEntryRequest.h"
+#include "model/GetVpdRouteEntryResult.h"
 #include "model/InitializeVccRequest.h"
 #include "model/InitializeVccResult.h"
+#include "model/ListElasticNetworkInterfacesRequest.h"
+#include "model/ListElasticNetworkInterfacesResult.h"
+#include "model/ListErAttachmentsRequest.h"
+#include "model/ListErAttachmentsResult.h"
+#include "model/ListErRouteEntriesRequest.h"
+#include "model/ListErRouteEntriesResult.h"
+#include "model/ListErRouteMapsRequest.h"
+#include "model/ListErRouteMapsResult.h"
+#include "model/ListErsRequest.h"
+#include "model/ListErsResult.h"
+#include "model/ListInstancesByNcdRequest.h"
+#include "model/ListInstancesByNcdResult.h"
+#include "model/ListLniPrivateIpAddressRequest.h"
+#include "model/ListLniPrivateIpAddressResult.h"
+#include "model/ListNetworkInterfacesRequest.h"
+#include "model/ListNetworkInterfacesResult.h"
 #include "model/ListSubnetsRequest.h"
 #include "model/ListSubnetsResult.h"
+#include "model/ListVccGrantRulesRequest.h"
+#include "model/ListVccGrantRulesResult.h"
+#include "model/ListVccRouteEntriesRequest.h"
+#include "model/ListVccRouteEntriesResult.h"
 #include "model/ListVccsRequest.h"
 #include "model/ListVccsResult.h"
+#include "model/ListVpdGrantRulesRequest.h"
+#include "model/ListVpdGrantRulesResult.h"
+#include "model/ListVpdRouteEntriesRequest.h"
+#include "model/ListVpdRouteEntriesResult.h"
 #include "model/ListVpdsRequest.h"
 #include "model/ListVpdsResult.h"
+#include "model/QueryInstanceNcdRequest.h"
+#include "model/QueryInstanceNcdResult.h"
+#include "model/UnAssignPrivateIpAddressRequest.h"
+#include "model/UnAssignPrivateIpAddressResult.h"
+#include "model/UnAssociateVpdCidrBlockRequest.h"
+#include "model/UnAssociateVpdCidrBlockResult.h"
+#include "model/UpdateElasticNetworkInterfaceRequest.h"
+#include "model/UpdateElasticNetworkInterfaceResult.h"
+#include "model/UpdateErRequest.h"
+#include "model/UpdateErResult.h"
+#include "model/UpdateErAttachmentRequest.h"
+#include "model/UpdateErAttachmentResult.h"
+#include "model/UpdateErRouteMapRequest.h"
+#include "model/UpdateErRouteMapResult.h"
 #include "model/UpdateSubnetRequest.h"
 #include "model/UpdateSubnetResult.h"
 #include "model/UpdateVccRequest.h"
@@ -61,42 +157,186 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_EFLO_EXPORT EfloClient : public RpcServiceClient
 		{
 		public:
+			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;
+			typedef Outcome<Error, Model::AssociateVpdCidrBlockResult> AssociateVpdCidrBlockOutcome;
+			typedef std::future<AssociateVpdCidrBlockOutcome> AssociateVpdCidrBlockOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::AssociateVpdCidrBlockRequest&, const AssociateVpdCidrBlockOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateVpdCidrBlockAsyncHandler;
+			typedef Outcome<Error, Model::CreateElasticNetworkInterfaceResult> CreateElasticNetworkInterfaceOutcome;
+			typedef std::future<CreateElasticNetworkInterfaceOutcome> CreateElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateElasticNetworkInterfaceRequest&, const CreateElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::CreateErResult> CreateErOutcome;
+			typedef std::future<CreateErOutcome> CreateErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateErRequest&, const CreateErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateErAsyncHandler;
+			typedef Outcome<Error, Model::CreateErAttachmentResult> CreateErAttachmentOutcome;
+			typedef std::future<CreateErAttachmentOutcome> CreateErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateErAttachmentRequest&, const CreateErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::CreateErRouteMapResult> CreateErRouteMapOutcome;
+			typedef std::future<CreateErRouteMapOutcome> CreateErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateErRouteMapRequest&, const CreateErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateErRouteMapAsyncHandler;
 			typedef Outcome<Error, Model::CreateSubnetResult> CreateSubnetOutcome;
 			typedef std::future<CreateSubnetOutcome> CreateSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::CreateSubnetRequest&, const CreateSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSubnetAsyncHandler;
 			typedef Outcome<Error, Model::CreateVccResult> CreateVccOutcome;
 			typedef std::future<CreateVccOutcome> CreateVccOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::CreateVccRequest&, const CreateVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccAsyncHandler;
+			typedef Outcome<Error, Model::CreateVccGrantRuleResult> CreateVccGrantRuleOutcome;
+			typedef std::future<CreateVccGrantRuleOutcome> CreateVccGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateVccGrantRuleRequest&, const CreateVccGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::CreateVccRouteEntryResult> CreateVccRouteEntryOutcome;
+			typedef std::future<CreateVccRouteEntryOutcome> CreateVccRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateVccRouteEntryRequest&, const CreateVccRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVccRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::CreateVpdResult> CreateVpdOutcome;
 			typedef std::future<CreateVpdOutcome> CreateVpdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::CreateVpdRequest&, const CreateVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpdAsyncHandler;
+			typedef Outcome<Error, Model::CreateVpdGrantRuleResult> CreateVpdGrantRuleOutcome;
+			typedef std::future<CreateVpdGrantRuleOutcome> CreateVpdGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::CreateVpdGrantRuleRequest&, const CreateVpdGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpdGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteElasticNetworkInterfaceResult> DeleteElasticNetworkInterfaceOutcome;
+			typedef std::future<DeleteElasticNetworkInterfaceOutcome> DeleteElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteElasticNetworkInterfaceRequest&, const DeleteElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteErResult> DeleteErOutcome;
+			typedef std::future<DeleteErOutcome> DeleteErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteErRequest&, const DeleteErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteErAsyncHandler;
+			typedef Outcome<Error, Model::DeleteErAttachmentResult> DeleteErAttachmentOutcome;
+			typedef std::future<DeleteErAttachmentOutcome> DeleteErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteErAttachmentRequest&, const DeleteErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::DeleteErRouteMapResult> DeleteErRouteMapOutcome;
+			typedef std::future<DeleteErRouteMapOutcome> DeleteErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteErRouteMapRequest&, const DeleteErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteErRouteMapAsyncHandler;
 			typedef Outcome<Error, Model::DeleteSubnetResult> DeleteSubnetOutcome;
 			typedef std::future<DeleteSubnetOutcome> DeleteSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::DeleteSubnetRequest&, const DeleteSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSubnetAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVccGrantRuleResult> DeleteVccGrantRuleOutcome;
+			typedef std::future<DeleteVccGrantRuleOutcome> DeleteVccGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteVccGrantRuleRequest&, const DeleteVccGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVccGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVccRouteEntryResult> DeleteVccRouteEntryOutcome;
+			typedef std::future<DeleteVccRouteEntryOutcome> DeleteVccRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteVccRouteEntryRequest&, const DeleteVccRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVccRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::DeleteVpdResult> DeleteVpdOutcome;
 			typedef std::future<DeleteVpdOutcome> DeleteVpdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::DeleteVpdRequest&, const DeleteVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpdAsyncHandler;
+			typedef Outcome<Error, Model::DeleteVpdGrantRuleResult> DeleteVpdGrantRuleOutcome;
+			typedef std::future<DeleteVpdGrantRuleOutcome> DeleteVpdGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DeleteVpdGrantRuleRequest&, const DeleteVpdGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpdGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSlrResult> DescribeSlrOutcome;
+			typedef std::future<DescribeSlrOutcome> DescribeSlrOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::DescribeSlrRequest&, const DescribeSlrOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlrAsyncHandler;
+			typedef Outcome<Error, Model::GetElasticNetworkInterfaceResult> GetElasticNetworkInterfaceOutcome;
+			typedef std::future<GetElasticNetworkInterfaceOutcome> GetElasticNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetElasticNetworkInterfaceRequest&, const GetElasticNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetElasticNetworkInterfaceAsyncHandler;
+			typedef Outcome<Error, Model::GetErResult> GetErOutcome;
+			typedef std::future<GetErOutcome> GetErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErRequest&, const GetErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErAsyncHandler;
+			typedef Outcome<Error, Model::GetErAttachmentResult> GetErAttachmentOutcome;
+			typedef std::future<GetErAttachmentOutcome> GetErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErAttachmentRequest&, const GetErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErAttachmentAsyncHandler;
+			typedef Outcome<Error, Model::GetErRouteEntryResult> GetErRouteEntryOutcome;
+			typedef std::future<GetErRouteEntryOutcome> GetErRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErRouteEntryRequest&, const GetErRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErRouteEntryAsyncHandler;
+			typedef Outcome<Error, Model::GetErRouteMapResult> GetErRouteMapOutcome;
+			typedef std::future<GetErRouteMapOutcome> GetErRouteMapOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetErRouteMapRequest&, const GetErRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetErRouteMapAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::GetNetworkInterfaceResult> GetNetworkInterfaceOutcome;
+			typedef std::future<GetNetworkInterfaceOutcome> GetNetworkInterfaceOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetNetworkInterfaceRequest&, const GetNetworkInterfaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNetworkInterfaceAsyncHandler;
 			typedef Outcome<Error, Model::GetSubnetResult> GetSubnetOutcome;
 			typedef std::future<GetSubnetOutcome> GetSubnetOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetSubnetRequest&, const GetSubnetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSubnetAsyncHandler;
 			typedef Outcome<Error, Model::GetVccResult> GetVccOutcome;
 			typedef std::future<GetVccOutcome> GetVccOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetVccRequest&, const GetVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccAsyncHandler;
+			typedef Outcome<Error, Model::GetVccGrantRuleResult> GetVccGrantRuleOutcome;
+			typedef std::future<GetVccGrantRuleOutcome> GetVccGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVccGrantRuleRequest&, const GetVccGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetVccRouteEntryResult> GetVccRouteEntryOutcome;
+			typedef std::future<GetVccRouteEntryOutcome> GetVccRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVccRouteEntryRequest&, const GetVccRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVccRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::GetVpdResult> GetVpdOutcome;
 			typedef std::future<GetVpdOutcome> GetVpdOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::GetVpdRequest&, const GetVpdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdAsyncHandler;
+			typedef Outcome<Error, Model::GetVpdGrantRuleResult> GetVpdGrantRuleOutcome;
+			typedef std::future<GetVpdGrantRuleOutcome> GetVpdGrantRuleOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVpdGrantRuleRequest&, const GetVpdGrantRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdGrantRuleAsyncHandler;
+			typedef Outcome<Error, Model::GetVpdRouteEntryResult> GetVpdRouteEntryOutcome;
+			typedef std::future<GetVpdRouteEntryOutcome> GetVpdRouteEntryOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::GetVpdRouteEntryRequest&, const GetVpdRouteEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpdRouteEntryAsyncHandler;
 			typedef Outcome<Error, Model::InitializeVccResult> InitializeVccOutcome;
 			typedef std::future<InitializeVccOutcome> InitializeVccOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::InitializeVccRequest&, const InitializeVccOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InitializeVccAsyncHandler;
+			typedef Outcome<Error, Model::ListElasticNetworkInterfacesResult> ListElasticNetworkInterfacesOutcome;
+			typedef std::future<ListElasticNetworkInterfacesOutcome> ListElasticNetworkInterfacesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListElasticNetworkInterfacesRequest&, const ListElasticNetworkInterfacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListElasticNetworkInterfacesAsyncHandler;
+			typedef Outcome<Error, Model::ListErAttachmentsResult> ListErAttachmentsOutcome;
+			typedef std::future<ListErAttachmentsOutcome> ListErAttachmentsOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErAttachmentsRequest&, const ListErAttachmentsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErAttachmentsAsyncHandler;
+			typedef Outcome<Error, Model::ListErRouteEntriesResult> ListErRouteEntriesOutcome;
+			typedef std::future<ListErRouteEntriesOutcome> ListErRouteEntriesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErRouteEntriesRequest&, const ListErRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErRouteEntriesAsyncHandler;
+			typedef Outcome<Error, Model::ListErRouteMapsResult> ListErRouteMapsOutcome;
+			typedef std::future<ListErRouteMapsOutcome> ListErRouteMapsOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErRouteMapsRequest&, const ListErRouteMapsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErRouteMapsAsyncHandler;
+			typedef Outcome<Error, Model::ListErsResult> ListErsOutcome;
+			typedef std::future<ListErsOutcome> ListErsOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListErsRequest&, const ListErsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListErsAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::ListNetworkInterfacesResult> ListNetworkInterfacesOutcome;
+			typedef std::future<ListNetworkInterfacesOutcome> ListNetworkInterfacesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListNetworkInterfacesRequest&, const ListNetworkInterfacesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNetworkInterfacesAsyncHandler;
 			typedef Outcome<Error, Model::ListSubnetsResult> ListSubnetsOutcome;
 			typedef std::future<ListSubnetsOutcome> ListSubnetsOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListSubnetsRequest&, const ListSubnetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSubnetsAsyncHandler;
+			typedef Outcome<Error, Model::ListVccGrantRulesResult> ListVccGrantRulesOutcome;
+			typedef std::future<ListVccGrantRulesOutcome> ListVccGrantRulesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVccGrantRulesRequest&, const ListVccGrantRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccGrantRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListVccRouteEntriesResult> ListVccRouteEntriesOutcome;
+			typedef std::future<ListVccRouteEntriesOutcome> ListVccRouteEntriesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVccRouteEntriesRequest&, const ListVccRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccRouteEntriesAsyncHandler;
 			typedef Outcome<Error, Model::ListVccsResult> ListVccsOutcome;
 			typedef std::future<ListVccsOutcome> ListVccsOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListVccsRequest&, const ListVccsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVccsAsyncHandler;
+			typedef Outcome<Error, Model::ListVpdGrantRulesResult> ListVpdGrantRulesOutcome;
+			typedef std::future<ListVpdGrantRulesOutcome> ListVpdGrantRulesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVpdGrantRulesRequest&, const ListVpdGrantRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdGrantRulesAsyncHandler;
+			typedef Outcome<Error, Model::ListVpdRouteEntriesResult> ListVpdRouteEntriesOutcome;
+			typedef std::future<ListVpdRouteEntriesOutcome> ListVpdRouteEntriesOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::ListVpdRouteEntriesRequest&, const ListVpdRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdRouteEntriesAsyncHandler;
 			typedef Outcome<Error, Model::ListVpdsResult> ListVpdsOutcome;
 			typedef std::future<ListVpdsOutcome> ListVpdsOutcomeCallable;
 			typedef std::function<void(const EfloClient*, const Model::ListVpdsRequest&, const ListVpdsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpdsAsyncHandler;
+			typedef Outcome<Error, Model::QueryInstanceNcdResult> QueryInstanceNcdOutcome;
+			typedef std::future<QueryInstanceNcdOutcome> QueryInstanceNcdOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::QueryInstanceNcdRequest&, const QueryInstanceNcdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryInstanceNcdAsyncHandler;
+			typedef Outcome<Error, Model::UnAssignPrivateIpAddressResult> UnAssignPrivateIpAddressOutcome;
+			typedef std::future<UnAssignPrivateIpAddressOutcome> UnAssignPrivateIpAddressOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UnAssignPrivateIpAddressRequest&, const UnAssignPrivateIpAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnAssignPrivateIpAddressAsyncHandler;
+			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::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;
+			typedef Outcome<Error, Model::UpdateErResult> UpdateErOutcome;
+			typedef std::future<UpdateErOutcome> UpdateErOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateErRequest&, const UpdateErOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErAsyncHandler;
+			typedef Outcome<Error, Model::UpdateErAttachmentResult> UpdateErAttachmentOutcome;
+			typedef std::future<UpdateErAttachmentOutcome> UpdateErAttachmentOutcomeCallable;
+			typedef std::function<void(const EfloClient*, const Model::UpdateErAttachmentRequest&, const UpdateErAttachmentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateErAttachmentAsyncHandler;
+			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::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;
@@ -111,42 +351,186 @@ 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();
+			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;
+			AssociateVpdCidrBlockOutcome associateVpdCidrBlock(const Model::AssociateVpdCidrBlockRequest &request)const;
+			void associateVpdCidrBlockAsync(const Model::AssociateVpdCidrBlockRequest& request, const AssociateVpdCidrBlockAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AssociateVpdCidrBlockOutcomeCallable associateVpdCidrBlockCallable(const Model::AssociateVpdCidrBlockRequest& request) const;
+			CreateElasticNetworkInterfaceOutcome createElasticNetworkInterface(const Model::CreateElasticNetworkInterfaceRequest &request)const;
+			void createElasticNetworkInterfaceAsync(const Model::CreateElasticNetworkInterfaceRequest& request, const CreateElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateElasticNetworkInterfaceOutcomeCallable createElasticNetworkInterfaceCallable(const Model::CreateElasticNetworkInterfaceRequest& request) const;
+			CreateErOutcome createEr(const Model::CreateErRequest &request)const;
+			void createErAsync(const Model::CreateErRequest& request, const CreateErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateErOutcomeCallable createErCallable(const Model::CreateErRequest& request) const;
+			CreateErAttachmentOutcome createErAttachment(const Model::CreateErAttachmentRequest &request)const;
+			void createErAttachmentAsync(const Model::CreateErAttachmentRequest& request, const CreateErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateErAttachmentOutcomeCallable createErAttachmentCallable(const Model::CreateErAttachmentRequest& request) const;
+			CreateErRouteMapOutcome createErRouteMap(const Model::CreateErRouteMapRequest &request)const;
+			void createErRouteMapAsync(const Model::CreateErRouteMapRequest& request, const CreateErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateErRouteMapOutcomeCallable createErRouteMapCallable(const Model::CreateErRouteMapRequest& request) const;
 			CreateSubnetOutcome createSubnet(const Model::CreateSubnetRequest &request)const;
 			void createSubnetAsync(const Model::CreateSubnetRequest& request, const CreateSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateSubnetOutcomeCallable createSubnetCallable(const Model::CreateSubnetRequest& request) const;
 			CreateVccOutcome createVcc(const Model::CreateVccRequest &request)const;
 			void createVccAsync(const Model::CreateVccRequest& request, const CreateVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVccOutcomeCallable createVccCallable(const Model::CreateVccRequest& request) const;
+			CreateVccGrantRuleOutcome createVccGrantRule(const Model::CreateVccGrantRuleRequest &request)const;
+			void createVccGrantRuleAsync(const Model::CreateVccGrantRuleRequest& request, const CreateVccGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVccGrantRuleOutcomeCallable createVccGrantRuleCallable(const Model::CreateVccGrantRuleRequest& request) const;
+			CreateVccRouteEntryOutcome createVccRouteEntry(const Model::CreateVccRouteEntryRequest &request)const;
+			void createVccRouteEntryAsync(const Model::CreateVccRouteEntryRequest& request, const CreateVccRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVccRouteEntryOutcomeCallable createVccRouteEntryCallable(const Model::CreateVccRouteEntryRequest& request) const;
 			CreateVpdOutcome createVpd(const Model::CreateVpdRequest &request)const;
 			void createVpdAsync(const Model::CreateVpdRequest& request, const CreateVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVpdOutcomeCallable createVpdCallable(const Model::CreateVpdRequest& request) const;
+			CreateVpdGrantRuleOutcome createVpdGrantRule(const Model::CreateVpdGrantRuleRequest &request)const;
+			void createVpdGrantRuleAsync(const Model::CreateVpdGrantRuleRequest& request, const CreateVpdGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateVpdGrantRuleOutcomeCallable createVpdGrantRuleCallable(const Model::CreateVpdGrantRuleRequest& request) const;
+			DeleteElasticNetworkInterfaceOutcome deleteElasticNetworkInterface(const Model::DeleteElasticNetworkInterfaceRequest &request)const;
+			void deleteElasticNetworkInterfaceAsync(const Model::DeleteElasticNetworkInterfaceRequest& request, const DeleteElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteElasticNetworkInterfaceOutcomeCallable deleteElasticNetworkInterfaceCallable(const Model::DeleteElasticNetworkInterfaceRequest& request) const;
+			DeleteErOutcome deleteEr(const Model::DeleteErRequest &request)const;
+			void deleteErAsync(const Model::DeleteErRequest& request, const DeleteErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteErOutcomeCallable deleteErCallable(const Model::DeleteErRequest& request) const;
+			DeleteErAttachmentOutcome deleteErAttachment(const Model::DeleteErAttachmentRequest &request)const;
+			void deleteErAttachmentAsync(const Model::DeleteErAttachmentRequest& request, const DeleteErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteErAttachmentOutcomeCallable deleteErAttachmentCallable(const Model::DeleteErAttachmentRequest& request) const;
+			DeleteErRouteMapOutcome deleteErRouteMap(const Model::DeleteErRouteMapRequest &request)const;
+			void deleteErRouteMapAsync(const Model::DeleteErRouteMapRequest& request, const DeleteErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteErRouteMapOutcomeCallable deleteErRouteMapCallable(const Model::DeleteErRouteMapRequest& request) const;
 			DeleteSubnetOutcome deleteSubnet(const Model::DeleteSubnetRequest &request)const;
 			void deleteSubnetAsync(const Model::DeleteSubnetRequest& request, const DeleteSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteSubnetOutcomeCallable deleteSubnetCallable(const Model::DeleteSubnetRequest& request) const;
+			DeleteVccGrantRuleOutcome deleteVccGrantRule(const Model::DeleteVccGrantRuleRequest &request)const;
+			void deleteVccGrantRuleAsync(const Model::DeleteVccGrantRuleRequest& request, const DeleteVccGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVccGrantRuleOutcomeCallable deleteVccGrantRuleCallable(const Model::DeleteVccGrantRuleRequest& request) const;
+			DeleteVccRouteEntryOutcome deleteVccRouteEntry(const Model::DeleteVccRouteEntryRequest &request)const;
+			void deleteVccRouteEntryAsync(const Model::DeleteVccRouteEntryRequest& request, const DeleteVccRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVccRouteEntryOutcomeCallable deleteVccRouteEntryCallable(const Model::DeleteVccRouteEntryRequest& request) const;
 			DeleteVpdOutcome deleteVpd(const Model::DeleteVpdRequest &request)const;
 			void deleteVpdAsync(const Model::DeleteVpdRequest& request, const DeleteVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteVpdOutcomeCallable deleteVpdCallable(const Model::DeleteVpdRequest& request) const;
+			DeleteVpdGrantRuleOutcome deleteVpdGrantRule(const Model::DeleteVpdGrantRuleRequest &request)const;
+			void deleteVpdGrantRuleAsync(const Model::DeleteVpdGrantRuleRequest& request, const DeleteVpdGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteVpdGrantRuleOutcomeCallable deleteVpdGrantRuleCallable(const Model::DeleteVpdGrantRuleRequest& request) const;
+			DescribeSlrOutcome describeSlr(const Model::DescribeSlrRequest &request)const;
+			void describeSlrAsync(const Model::DescribeSlrRequest& request, const DescribeSlrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSlrOutcomeCallable describeSlrCallable(const Model::DescribeSlrRequest& request) const;
+			GetElasticNetworkInterfaceOutcome getElasticNetworkInterface(const Model::GetElasticNetworkInterfaceRequest &request)const;
+			void getElasticNetworkInterfaceAsync(const Model::GetElasticNetworkInterfaceRequest& request, const GetElasticNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetElasticNetworkInterfaceOutcomeCallable getElasticNetworkInterfaceCallable(const Model::GetElasticNetworkInterfaceRequest& request) const;
+			GetErOutcome getEr(const Model::GetErRequest &request)const;
+			void getErAsync(const Model::GetErRequest& request, const GetErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErOutcomeCallable getErCallable(const Model::GetErRequest& request) const;
+			GetErAttachmentOutcome getErAttachment(const Model::GetErAttachmentRequest &request)const;
+			void getErAttachmentAsync(const Model::GetErAttachmentRequest& request, const GetErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErAttachmentOutcomeCallable getErAttachmentCallable(const Model::GetErAttachmentRequest& request) const;
+			GetErRouteEntryOutcome getErRouteEntry(const Model::GetErRouteEntryRequest &request)const;
+			void getErRouteEntryAsync(const Model::GetErRouteEntryRequest& request, const GetErRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErRouteEntryOutcomeCallable getErRouteEntryCallable(const Model::GetErRouteEntryRequest& request) const;
+			GetErRouteMapOutcome getErRouteMap(const Model::GetErRouteMapRequest &request)const;
+			void getErRouteMapAsync(const Model::GetErRouteMapRequest& request, const GetErRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetErRouteMapOutcomeCallable getErRouteMapCallable(const Model::GetErRouteMapRequest& request) const;
+			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;
+			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;
+			GetNetworkInterfaceOutcome getNetworkInterface(const Model::GetNetworkInterfaceRequest &request)const;
+			void getNetworkInterfaceAsync(const Model::GetNetworkInterfaceRequest& request, const GetNetworkInterfaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNetworkInterfaceOutcomeCallable getNetworkInterfaceCallable(const Model::GetNetworkInterfaceRequest& request) const;
 			GetSubnetOutcome getSubnet(const Model::GetSubnetRequest &request)const;
 			void getSubnetAsync(const Model::GetSubnetRequest& request, const GetSubnetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetSubnetOutcomeCallable getSubnetCallable(const Model::GetSubnetRequest& request) const;
 			GetVccOutcome getVcc(const Model::GetVccRequest &request)const;
 			void getVccAsync(const Model::GetVccRequest& request, const GetVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVccOutcomeCallable getVccCallable(const Model::GetVccRequest& request) const;
+			GetVccGrantRuleOutcome getVccGrantRule(const Model::GetVccGrantRuleRequest &request)const;
+			void getVccGrantRuleAsync(const Model::GetVccGrantRuleRequest& request, const GetVccGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVccGrantRuleOutcomeCallable getVccGrantRuleCallable(const Model::GetVccGrantRuleRequest& request) const;
+			GetVccRouteEntryOutcome getVccRouteEntry(const Model::GetVccRouteEntryRequest &request)const;
+			void getVccRouteEntryAsync(const Model::GetVccRouteEntryRequest& request, const GetVccRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVccRouteEntryOutcomeCallable getVccRouteEntryCallable(const Model::GetVccRouteEntryRequest& request) const;
 			GetVpdOutcome getVpd(const Model::GetVpdRequest &request)const;
 			void getVpdAsync(const Model::GetVpdRequest& request, const GetVpdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetVpdOutcomeCallable getVpdCallable(const Model::GetVpdRequest& request) const;
+			GetVpdGrantRuleOutcome getVpdGrantRule(const Model::GetVpdGrantRuleRequest &request)const;
+			void getVpdGrantRuleAsync(const Model::GetVpdGrantRuleRequest& request, const GetVpdGrantRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVpdGrantRuleOutcomeCallable getVpdGrantRuleCallable(const Model::GetVpdGrantRuleRequest& request) const;
+			GetVpdRouteEntryOutcome getVpdRouteEntry(const Model::GetVpdRouteEntryRequest &request)const;
+			void getVpdRouteEntryAsync(const Model::GetVpdRouteEntryRequest& request, const GetVpdRouteEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVpdRouteEntryOutcomeCallable getVpdRouteEntryCallable(const Model::GetVpdRouteEntryRequest& request) const;
 			InitializeVccOutcome initializeVcc(const Model::InitializeVccRequest &request)const;
 			void initializeVccAsync(const Model::InitializeVccRequest& request, const InitializeVccAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			InitializeVccOutcomeCallable initializeVccCallable(const Model::InitializeVccRequest& request) const;
+			ListElasticNetworkInterfacesOutcome listElasticNetworkInterfaces(const Model::ListElasticNetworkInterfacesRequest &request)const;
+			void listElasticNetworkInterfacesAsync(const Model::ListElasticNetworkInterfacesRequest& request, const ListElasticNetworkInterfacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListElasticNetworkInterfacesOutcomeCallable listElasticNetworkInterfacesCallable(const Model::ListElasticNetworkInterfacesRequest& request) const;
+			ListErAttachmentsOutcome listErAttachments(const Model::ListErAttachmentsRequest &request)const;
+			void listErAttachmentsAsync(const Model::ListErAttachmentsRequest& request, const ListErAttachmentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErAttachmentsOutcomeCallable listErAttachmentsCallable(const Model::ListErAttachmentsRequest& request) const;
+			ListErRouteEntriesOutcome listErRouteEntries(const Model::ListErRouteEntriesRequest &request)const;
+			void listErRouteEntriesAsync(const Model::ListErRouteEntriesRequest& request, const ListErRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErRouteEntriesOutcomeCallable listErRouteEntriesCallable(const Model::ListErRouteEntriesRequest& request) const;
+			ListErRouteMapsOutcome listErRouteMaps(const Model::ListErRouteMapsRequest &request)const;
+			void listErRouteMapsAsync(const Model::ListErRouteMapsRequest& request, const ListErRouteMapsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErRouteMapsOutcomeCallable listErRouteMapsCallable(const Model::ListErRouteMapsRequest& request) const;
+			ListErsOutcome listErs(const Model::ListErsRequest &request)const;
+			void listErsAsync(const Model::ListErsRequest& request, const ListErsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListErsOutcomeCallable listErsCallable(const Model::ListErsRequest& request) const;
+			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;
+			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;
+			ListNetworkInterfacesOutcome listNetworkInterfaces(const Model::ListNetworkInterfacesRequest &request)const;
+			void listNetworkInterfacesAsync(const Model::ListNetworkInterfacesRequest& request, const ListNetworkInterfacesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNetworkInterfacesOutcomeCallable listNetworkInterfacesCallable(const Model::ListNetworkInterfacesRequest& request) const;
 			ListSubnetsOutcome listSubnets(const Model::ListSubnetsRequest &request)const;
 			void listSubnetsAsync(const Model::ListSubnetsRequest& request, const ListSubnetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListSubnetsOutcomeCallable listSubnetsCallable(const Model::ListSubnetsRequest& request) const;
+			ListVccGrantRulesOutcome listVccGrantRules(const Model::ListVccGrantRulesRequest &request)const;
+			void listVccGrantRulesAsync(const Model::ListVccGrantRulesRequest& request, const ListVccGrantRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVccGrantRulesOutcomeCallable listVccGrantRulesCallable(const Model::ListVccGrantRulesRequest& request) const;
+			ListVccRouteEntriesOutcome listVccRouteEntries(const Model::ListVccRouteEntriesRequest &request)const;
+			void listVccRouteEntriesAsync(const Model::ListVccRouteEntriesRequest& request, const ListVccRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVccRouteEntriesOutcomeCallable listVccRouteEntriesCallable(const Model::ListVccRouteEntriesRequest& request) const;
 			ListVccsOutcome listVccs(const Model::ListVccsRequest &request)const;
 			void listVccsAsync(const Model::ListVccsRequest& request, const ListVccsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListVccsOutcomeCallable listVccsCallable(const Model::ListVccsRequest& request) const;
+			ListVpdGrantRulesOutcome listVpdGrantRules(const Model::ListVpdGrantRulesRequest &request)const;
+			void listVpdGrantRulesAsync(const Model::ListVpdGrantRulesRequest& request, const ListVpdGrantRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpdGrantRulesOutcomeCallable listVpdGrantRulesCallable(const Model::ListVpdGrantRulesRequest& request) const;
+			ListVpdRouteEntriesOutcome listVpdRouteEntries(const Model::ListVpdRouteEntriesRequest &request)const;
+			void listVpdRouteEntriesAsync(const Model::ListVpdRouteEntriesRequest& request, const ListVpdRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListVpdRouteEntriesOutcomeCallable listVpdRouteEntriesCallable(const Model::ListVpdRouteEntriesRequest& request) const;
 			ListVpdsOutcome listVpds(const Model::ListVpdsRequest &request)const;
 			void listVpdsAsync(const Model::ListVpdsRequest& request, const ListVpdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListVpdsOutcomeCallable listVpdsCallable(const Model::ListVpdsRequest& request) const;
+			QueryInstanceNcdOutcome queryInstanceNcd(const Model::QueryInstanceNcdRequest &request)const;
+			void queryInstanceNcdAsync(const Model::QueryInstanceNcdRequest& request, const QueryInstanceNcdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryInstanceNcdOutcomeCallable queryInstanceNcdCallable(const Model::QueryInstanceNcdRequest& request) const;
+			UnAssignPrivateIpAddressOutcome unAssignPrivateIpAddress(const Model::UnAssignPrivateIpAddressRequest &request)const;
+			void unAssignPrivateIpAddressAsync(const Model::UnAssignPrivateIpAddressRequest& request, const UnAssignPrivateIpAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnAssignPrivateIpAddressOutcomeCallable unAssignPrivateIpAddressCallable(const Model::UnAssignPrivateIpAddressRequest& request) const;
+			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;
+			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;
+			UpdateErOutcome updateEr(const Model::UpdateErRequest &request)const;
+			void updateErAsync(const Model::UpdateErRequest& request, const UpdateErAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateErOutcomeCallable updateErCallable(const Model::UpdateErRequest& request) const;
+			UpdateErAttachmentOutcome updateErAttachment(const Model::UpdateErAttachmentRequest &request)const;
+			void updateErAttachmentAsync(const Model::UpdateErAttachmentRequest& request, const UpdateErAttachmentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateErAttachmentOutcomeCallable updateErAttachmentCallable(const Model::UpdateErAttachmentRequest& request) const;
+			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;
 			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/AssignPrivateIpAddressRequest.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_ASSIGNPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSREQUEST_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 AssignPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	AssignPrivateIpAddressRequest();
+	~AssignPrivateIpAddressRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	bool getAssignMac() const;
+	void setAssignMac(bool assignMac);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getSubnetId() const;
+	void setSubnetId(const std::string &subnetId);
+	bool getSkipConfig() const;
+	void setSkipConfig(bool skipConfig);
+	std::string getPrivateIpAddress() const;
+	void setPrivateIpAddress(const std::string &privateIpAddress);
+	std::string getNetworkInterfaceId() const;
+	void setNetworkInterfaceId(const std::string &networkInterfaceId);
+
+private:
+	std::string description_;
+	bool assignMac_;
+	std::string regionId_;
+	std::string subnetId_;
+	bool skipConfig_;
+	std::string privateIpAddress_;
+	std::string networkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/AssignPrivateIpAddressResult.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_ASSIGNPRIVATEIPADDRESSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSIGNPRIVATEIPADDRESSRESULT_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 AssignPrivateIpAddressResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string ipName;
+					std::string networkInterfaceId;
+				};
+
+
+				AssignPrivateIpAddressResult();
+				explicit AssignPrivateIpAddressResult(const std::string &payload);
+				~AssignPrivateIpAddressResult();
+				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_ASSIGNPRIVATEIPADDRESSRESULT_H_

eflo/include/alibabacloud/eflo/model/AssociateVpdCidrBlockRequest.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_ASSOCIATEVPDCIDRBLOCKREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKREQUEST_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 AssociateVpdCidrBlockRequest : public RpcServiceRequest {
+public:
+	AssociateVpdCidrBlockRequest();
+	~AssociateVpdCidrBlockRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+	std::string getSecondaryCidrBlock() const;
+	void setSecondaryCidrBlock(const std::string &secondaryCidrBlock);
+
+private:
+	std::string regionId_;
+	std::string vpdId_;
+	std::string secondaryCidrBlock_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKREQUEST_H_

eflo/include/alibabacloud/eflo/model/AssociateVpdCidrBlockResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_ASSOCIATEVPDCIDRBLOCKRESULT_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 AssociateVpdCidrBlockResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string vpdId;
+				};
+
+
+				AssociateVpdCidrBlockResult();
+				explicit AssociateVpdCidrBlockResult(const std::string &payload);
+				~AssociateVpdCidrBlockResult();
+				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_ASSOCIATEVPDCIDRBLOCKRESULT_H_

eflo/include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACEREQUEST_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 CreateElasticNetworkInterfaceRequest : public RpcServiceRequest {
+public:
+	CreateElasticNetworkInterfaceRequest();
+	~CreateElasticNetworkInterfaceRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getNodeId() const;
+	void setNodeId(const std::string &nodeId);
+
+private:
+	std::string description_;
+	std::string vSwitchId_;
+	std::string regionId_;
+	std::string vpcId_;
+	std::string zoneId_;
+	std::string nodeId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACEREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateElasticNetworkInterfaceResult.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_CREATEELASTICNETWORKINTERFACERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEELASTICNETWORKINTERFACERESULT_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 CreateElasticNetworkInterfaceResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string elasticNetworkInterfaceId;
+					std::string nodeId;
+				};
+
+
+				CreateElasticNetworkInterfaceResult();
+				explicit CreateElasticNetworkInterfaceResult(const std::string &payload);
+				~CreateElasticNetworkInterfaceResult();
+				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_CREATEELASTICNETWORKINTERFACERESULT_H_

eflo/include/alibabacloud/eflo/model/CreateErAttachmentRequest.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_CREATEERATTACHMENTREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERATTACHMENTREQUEST_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 CreateErAttachmentRequest : public RpcServiceRequest {
+public:
+	CreateErAttachmentRequest();
+	~CreateErAttachmentRequest();
+	std::string getResourceTenantId() const;
+	void setResourceTenantId(const std::string &resourceTenantId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getAutoReceiveAllRoute() const;
+	void setAutoReceiveAllRoute(bool autoReceiveAllRoute);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getErAttachmentName() const;
+	void setErAttachmentName(const std::string &erAttachmentName);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+
+private:
+	std::string resourceTenantId_;
+	std::string regionId_;
+	bool autoReceiveAllRoute_;
+	std::string instanceType_;
+	std::string erAttachmentName_;
+	std::string erId_;
+	std::string instanceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEERATTACHMENTREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateErAttachmentResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEERATTACHMENTRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERATTACHMENTRESULT_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 CreateErAttachmentResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string erAttachmentId;
+				};
+
+
+				CreateErAttachmentResult();
+				explicit CreateErAttachmentResult(const std::string &payload);
+				~CreateErAttachmentResult();
+				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_CREATEERATTACHMENTRESULT_H_

eflo/include/alibabacloud/eflo/model/CreateErRequest.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_CREATEERREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERREQUEST_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 CreateErRequest : public RpcServiceRequest {
+public:
+	CreateErRequest();
+	~CreateErRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getErName() const;
+	void setErName(const std::string &erName);
+	std::string getMasterZoneId() const;
+	void setMasterZoneId(const std::string &masterZoneId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string description_;
+	std::string erName_;
+	std::string masterZoneId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEERREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateErResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEERRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERRESULT_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 CreateErResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string erId;
+				};
+
+
+				CreateErResult();
+				explicit CreateErResult(const std::string &payload);
+				~CreateErResult();
+				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_CREATEERRESULT_H_

eflo/include/alibabacloud/eflo/model/CreateErRouteMapRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPREQUEST_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 CreateErRouteMapRequest : public RpcServiceRequest {
+public:
+	CreateErRouteMapRequest();
+	~CreateErRouteMapRequest();
+	std::string getReceptionInstanceType() const;
+	void setReceptionInstanceType(const std::string &receptionInstanceType);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getReceptionInstanceId() const;
+	void setReceptionInstanceId(const std::string &receptionInstanceId);
+	std::string getRouteMapAction() const;
+	void setRouteMapAction(const std::string &routeMapAction);
+	std::string getTransmissionInstanceType() const;
+	void setTransmissionInstanceType(const std::string &transmissionInstanceType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	int getRouteMapNum() const;
+	void setRouteMapNum(int routeMapNum);
+	std::string getReceptionInstanceOwner() const;
+	void setReceptionInstanceOwner(const std::string &receptionInstanceOwner);
+	std::string getTransmissionInstanceOwner() const;
+	void setTransmissionInstanceOwner(const std::string &transmissionInstanceOwner);
+	std::string getTransmissionInstanceId() const;
+	void setTransmissionInstanceId(const std::string &transmissionInstanceId);
+
+private:
+	std::string receptionInstanceType_;
+	std::string description_;
+	std::string receptionInstanceId_;
+	std::string routeMapAction_;
+	std::string transmissionInstanceType_;
+	std::string regionId_;
+	std::string destinationCidrBlock_;
+	std::string erId_;
+	int routeMapNum_;
+	std::string receptionInstanceOwner_;
+	std::string transmissionInstanceOwner_;
+	std::string transmissionInstanceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateErRouteMapResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEERROUTEMAPRESULT_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 CreateErRouteMapResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string erRouteMapId;
+				};
+
+
+				CreateErRouteMapResult();
+				explicit CreateErRouteMapResult(const std::string &payload);
+				~CreateErRouteMapResult();
+				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_CREATEERROUTEMAPRESULT_H_

eflo/include/alibabacloud/eflo/model/CreateSubnetRequest.h

@@ -28,28 +28,35 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT CreateSubnetRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateSubnetRequest();
 	~CreateSubnetRequest();
 	std::string getType() const;
 	void setType(const std::string &type);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	std::string getCidr() const;
+	void setCidr(const std::string &cidr);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getVpdId() const;
 	void setVpdId(const std::string &vpdId);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getZoneId() const;
 	void setZoneId(const std::string &zoneId);
-	std::string getCidr() const;
-	void setCidr(const std::string &cidr);
+	std::string getSubnetName() const;
+	void setSubnetName(const std::string &subnetName);
 
 private:
 	std::string type_;
 	std::string regionId_;
+	std::string cidr_;
+	std::vector<Tag> tag_;
 	std::string vpdId_;
-	std::string name_;
 	std::string zoneId_;
-	std::string cidr_;
+	std::string subnetName_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/CreateVccGrantRuleRequest.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_CREATEVCCGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCGRANTRULEREQUEST_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 CreateVccGrantRuleRequest : public RpcServiceRequest {
+public:
+	CreateVccGrantRuleRequest();
+	~CreateVccGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string grantTenantId_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCGRANTRULEREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateVccGrantRuleResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEVCCGRANTRULERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCGRANTRULERESULT_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 CreateVccGrantRuleResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string grantRuleId;
+				};
+
+
+				CreateVccGrantRuleResult();
+				explicit CreateVccGrantRuleResult(const std::string &payload);
+				~CreateVccGrantRuleResult();
+				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_CREATEVCCGRANTRULERESULT_H_

eflo/include/alibabacloud/eflo/model/CreateVccRequest.h

@@ -28,6 +28,10 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT CreateVccRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateVccRequest();
 	~CreateVccRequest();
 	std::string getBgpCidr() const;
@@ -36,29 +40,50 @@ public:
 	void setCenId(const std::string &cenId);
 	std::string getDescription() const;
 	void setDescription(const std::string &description);
+	std::string getCenOwnerId() const;
+	void setCenOwnerId(const std::string &cenOwnerId);
 	bool getAccessCouldService() const;
 	void setAccessCouldService(bool accessCouldService);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getVccName() const;
+	void setVccName(const std::string &vccName);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getVccId() const;
 	void setVccId(const std::string &vccId);
+	std::string getConnectionType() const;
+	void setConnectionType(const std::string &connectionType);
+	int getBandwidth() const;
+	void setBandwidth(int bandwidth);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
 	std::string getVpdId() const;
 	void setVpdId(const std::string &vpdId);
 	std::string getVpcId() const;
 	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
 
 private:
 	std::string bgpCidr_;
 	std::string cenId_;
 	std::string description_;
+	std::string cenOwnerId_;
 	bool accessCouldService_;
+	std::string resourceGroupId_;
+	std::string vccName_;
 	std::string regionId_;
+	std::vector<Tag> tag_;
 	std::string vccId_;
+	std::string connectionType_;
+	int bandwidth_;
 	std::string vSwitchId_;
 	std::string vpdId_;
 	std::string vpcId_;
+	std::string zoneId_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/CreateVccRouteEntryRequest.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_CREATEVCCROUTEENTRYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCROUTEENTRYREQUEST_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 CreateVccRouteEntryRequest : public RpcServiceRequest {
+public:
+	CreateVccRouteEntryRequest();
+	~CreateVccRouteEntryRequest();
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVccId() const;
+	void setVccId(const std::string &vccId);
+
+private:
+	std::string destinationCidrBlock_;
+	std::string regionId_;
+	std::string vccId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVCCROUTEENTRYREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateVccRouteEntryResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEVCCROUTEENTRYRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVCCROUTEENTRYRESULT_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 CreateVccRouteEntryResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string vccRouteEntryId;
+				};
+
+
+				CreateVccRouteEntryResult();
+				explicit CreateVccRouteEntryResult(const std::string &payload);
+				~CreateVccRouteEntryResult();
+				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_CREATEVCCROUTEENTRYRESULT_H_

eflo/include/alibabacloud/eflo/model/CreateVpdGrantRuleRequest.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_CREATEVPDGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDGRANTRULEREQUEST_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 CreateVpdGrantRuleRequest : public RpcServiceRequest {
+public:
+	CreateVpdGrantRuleRequest();
+	~CreateVpdGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string grantTenantId_;
+	std::string instanceId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_CREATEVPDGRANTRULEREQUEST_H_

eflo/include/alibabacloud/eflo/model/CreateVpdGrantRuleResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_CREATEVPDGRANTRULERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_CREATEVPDGRANTRULERESULT_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 CreateVpdGrantRuleResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string grantRuleId;
+				};
+
+
+				CreateVpdGrantRuleResult();
+				explicit CreateVpdGrantRuleResult(const std::string &payload);
+				~CreateVpdGrantRuleResult();
+				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_CREATEVPDGRANTRULERESULT_H_

eflo/include/alibabacloud/eflo/model/CreateVpdRequest.h

@@ -30,27 +30,37 @@ class ALIBABACLOUD_EFLO_EXPORT CreateVpdRequest : public RpcServiceRequest {
 public:
 	struct Subnets {
 		std::string regionId;
-		std::string name;
 		std::string zoneId;
 		std::string cidr;
+		std::string subnetName;
 		std::string type;
 	};
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	CreateVpdRequest();
 	~CreateVpdRequest();
+	std::string getVpdName() const;
+	void setVpdName(const std::string &vpdName);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getCidr() const;
 	void setCidr(const std::string &cidr);
 	std::vector<Subnets> getSubnets() const;
 	void setSubnets(const std::vector<Subnets> &subnets);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 
 private:
+	std::string vpdName_;
+	std::string resourceGroupId_;
 	std::string regionId_;
-	std::string name_;
 	std::string cidr_;
 	std::vector<Subnets> subnets_;
+	std::vector<Tag> tag_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceRequest.h

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

eflo/include/alibabacloud/eflo/model/DeleteElasticNetworkInterfaceResult.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_DELETEELASTICNETWORKINTERFACERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEELASTICNETWORKINTERFACERESULT_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 DeleteElasticNetworkInterfaceResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string elasticNetworkInterfaceId;
+					std::string nodeId;
+				};
+
+
+				DeleteElasticNetworkInterfaceResult();
+				explicit DeleteElasticNetworkInterfaceResult(const std::string &payload);
+				~DeleteElasticNetworkInterfaceResult();
+				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_DELETEELASTICNETWORKINTERFACERESULT_H_

eflo/include/alibabacloud/eflo/model/DeleteErAttachmentRequest.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_DELETEERATTACHMENTREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEERATTACHMENTREQUEST_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 DeleteErAttachmentRequest : public RpcServiceRequest {
+public:
+	DeleteErAttachmentRequest();
+	~DeleteErAttachmentRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getErAttachmentId() const;
+	void setErAttachmentId(const std::string &erAttachmentId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string erAttachmentId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEERATTACHMENTREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteErAttachmentResult.h

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

eflo/include/alibabacloud/eflo/model/DeleteErRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_DELETEERREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEERREQUEST_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 DeleteErRequest : public RpcServiceRequest {
+public:
+	DeleteErRequest();
+	~DeleteErRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEERREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteErResult.h

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

eflo/include/alibabacloud/eflo/model/DeleteErRouteMapRequest.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_DELETEERROUTEMAPREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEERROUTEMAPREQUEST_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 DeleteErRouteMapRequest : public RpcServiceRequest {
+public:
+	DeleteErRouteMapRequest();
+	~DeleteErRouteMapRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::vector<std::string> getErRouteMapIds() const;
+	void setErRouteMapIds(const std::vector<std::string> &erRouteMapIds);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::vector<std::string> erRouteMapIds_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEERROUTEMAPREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteErRouteMapResult.h

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

eflo/include/alibabacloud/eflo/model/DeleteVccGrantRuleRequest.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_DELETEVCCGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEVCCGRANTRULEREQUEST_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 DeleteVccGrantRuleRequest : public RpcServiceRequest {
+public:
+	DeleteVccGrantRuleRequest();
+	~DeleteVccGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	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 instanceId_;
+	std::string regionId_;
+	std::string grantRuleId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVCCGRANTRULEREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteVccGrantRuleResult.h

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

eflo/include/alibabacloud/eflo/model/DeleteVccRouteEntryRequest.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_DELETEVCCROUTEENTRYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEVCCROUTEENTRYREQUEST_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 DeleteVccRouteEntryRequest : public RpcServiceRequest {
+public:
+	DeleteVccRouteEntryRequest();
+	~DeleteVccRouteEntryRequest();
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVccId() const;
+	void setVccId(const std::string &vccId);
+	std::string getVccRouteEntryId() const;
+	void setVccRouteEntryId(const std::string &vccRouteEntryId);
+
+private:
+	std::string destinationCidrBlock_;
+	std::string regionId_;
+	std::string vccId_;
+	std::string vccRouteEntryId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVCCROUTEENTRYREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteVccRouteEntryResult.h

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

eflo/include/alibabacloud/eflo/model/DeleteVpdGrantRuleRequest.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_DELETEVPDGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DELETEVPDGRANTRULEREQUEST_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 DeleteVpdGrantRuleRequest : public RpcServiceRequest {
+public:
+	DeleteVpdGrantRuleRequest();
+	~DeleteVpdGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	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);
+
+private:
+	std::string erId_;
+	std::string grantTenantId_;
+	std::string instanceId_;
+	std::string grantRuleId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DELETEVPDGRANTRULEREQUEST_H_

eflo/include/alibabacloud/eflo/model/DeleteVpdGrantRuleResult.h

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

eflo/include/alibabacloud/eflo/model/DescribeSlrRequest.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_DESCRIBESLRREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_DESCRIBESLRREQUEST_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 DescribeSlrRequest : public RpcServiceRequest {
+public:
+	DescribeSlrRequest();
+	~DescribeSlrRequest();
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+
+private:
+	std::string resourceGroupId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_DESCRIBESLRREQUEST_H_

eflo/include/alibabacloud/eflo/model/DescribeSlrResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_DESCRIBESLRRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_DESCRIBESLRRESULT_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 DescribeSlrResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					bool hasRole;
+				};
+
+
+				DescribeSlrResult();
+				explicit DescribeSlrResult(const std::string &payload);
+				~DescribeSlrResult();
+				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_DESCRIBESLRRESULT_H_

eflo/include/alibabacloud/eflo/model/GetElasticNetworkInterfaceRequest.h

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

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

@@ -0,0 +1,74 @@
+/*
+ * 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_GETELASTICNETWORKINTERFACERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETELASTICNETWORKINTERFACERESULT_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 GetElasticNetworkInterfaceResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string description;
+					std::string zoneId;
+					std::string message;
+					std::string ip;
+					std::string vSwitchId;
+					std::string createTime;
+					std::string mask;
+					std::string gmtModified;
+					std::string mac;
+					std::string elasticNetworkInterfaceId;
+					std::string type;
+					std::string vpcId;
+					std::string gateway;
+					std::string nodeId;
+					std::string regionId;
+				};
+
+
+				GetElasticNetworkInterfaceResult();
+				explicit GetElasticNetworkInterfaceResult(const std::string &payload);
+				~GetElasticNetworkInterfaceResult();
+				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_GETELASTICNETWORKINTERFACERESULT_H_

eflo/include/alibabacloud/eflo/model/GetErAttachmentRequest.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_GETERATTACHMENTREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERATTACHMENTREQUEST_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 GetErAttachmentRequest : public RpcServiceRequest {
+public:
+	GetErAttachmentRequest();
+	~GetErAttachmentRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getErAttachmentId() const;
+	void setErAttachmentId(const std::string &erAttachmentId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string erAttachmentId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETERATTACHMENTREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetErAttachmentResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETERATTACHMENTRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERATTACHMENTRESULT_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 GetErAttachmentResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string message;
+					std::string instanceId;
+					std::string createTime;
+					std::string gmtModified;
+					std::string erId;
+					bool across;
+					std::string instanceName;
+					std::string tenantId;
+					std::string resourceTenantId;
+					bool autoReceiveAllRoute;
+					std::string erAttachmentName;
+					std::string erAttachmentId;
+					std::string regionId;
+					std::string instanceType;
+				};
+
+
+				GetErAttachmentResult();
+				explicit GetErAttachmentResult(const std::string &payload);
+				~GetErAttachmentResult();
+				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_GETERATTACHMENTRESULT_H_

eflo/include/alibabacloud/eflo/model/GetErRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETERREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERREQUEST_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 GetErRequest : public RpcServiceRequest {
+public:
+	GetErRequest();
+	~GetErRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETERREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetErResult.h

@@ -0,0 +1,127 @@
+/*
+ * 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_GETERRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERRESULT_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 GetErResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct ErAttachment
+					{
+						std::string status;
+						std::string message;
+						std::string instanceId;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						bool across;
+						std::string instanceName;
+						std::string tenantId;
+						std::string resourceTenantId;
+						bool autoReceiveAllRoute;
+						std::string erAttachmentName;
+						std::string erAttachmentId;
+						std::string regionId;
+						std::string instanceType;
+					};
+					struct ErRouteMap
+					{
+						std::string status;
+						std::string transmissionInstanceType;
+						std::string action;
+						std::string description;
+						std::string receptionInstanceType;
+						std::string message;
+						std::string erRouteMapName;
+						std::string receptionInstanceId;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						std::string transmissionInstanceName;
+						std::string destinationCidrBlock;
+						std::string receptionInstanceOwner;
+						std::string tenantId;
+						std::string receptionInstanceName;
+						std::string erRouteMapId;
+						std::string transmissionInstanceOwner;
+						std::string regionId;
+						std::string transmissionInstanceId;
+						int routeMapNum;
+					};
+					struct ErRouteEntry
+					{
+						std::string status;
+						std::string nextHopType;
+						std::string tenantId;
+						std::string resourceTenantId;
+						std::string routeType;
+						std::string erRouteEntryId;
+						std::string nextHopId;
+						std::string gmtModified;
+						std::string erId;
+						std::string regionId;
+						std::string destinationCidrBlock;
+					};
+					std::string status;
+					std::string description;
+					std::string message;
+					std::string createTime;
+					std::string gmtModified;
+					std::string erId;
+					std::vector<ErAttachment> erAttachments;
+					std::vector<ErRouteEntry> erRouteEntrys;
+					std::string erName;
+					std::string tenantId;
+					std::vector<ErRouteMap> erRouteMaps;
+					std::string regionId;
+					std::string masterZoneId;
+				};
+
+
+				GetErResult();
+				explicit GetErResult(const std::string &payload);
+				~GetErResult();
+				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_GETERRESULT_H_

eflo/include/alibabacloud/eflo/model/GetErRouteEntryRequest.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_GETERROUTEENTRYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERROUTEENTRYREQUEST_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 GetErRouteEntryRequest : public RpcServiceRequest {
+public:
+	GetErRouteEntryRequest();
+	~GetErRouteEntryRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getErRouteEntryId() const;
+	void setErRouteEntryId(const std::string &erRouteEntryId);
+
+private:
+	std::string erId_;
+	std::string regionId_;
+	std::string erRouteEntryId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETERROUTEENTRYREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetErRouteEntryResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETERROUTEENTRYRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERROUTEENTRYRESULT_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 GetErRouteEntryResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string nextHopType;
+					std::string tenantId;
+					std::string routeType;
+					std::string erRouteEntryId;
+					std::string nextHopId;
+					std::string gmtModified;
+					std::string erId;
+					std::string regionId;
+					std::string destinationCidrBlock;
+				};
+
+
+				GetErRouteEntryResult();
+				explicit GetErRouteEntryResult(const std::string &payload);
+				~GetErRouteEntryResult();
+				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_GETERROUTEENTRYRESULT_H_

eflo/include/alibabacloud/eflo/model/GetErRouteMapRequest.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_GETERROUTEMAPREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERROUTEMAPREQUEST_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 GetErRouteMapRequest : public RpcServiceRequest {
+public:
+	GetErRouteMapRequest();
+	~GetErRouteMapRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getErRouteMapId() const;
+	void setErRouteMapId(const std::string &erRouteMapId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string erId_;
+	std::string erRouteMapId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETERROUTEMAPREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetErRouteMapResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETERROUTEMAPRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETERROUTEMAPRESULT_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 GetErRouteMapResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string transmissionInstanceType;
+					std::string action;
+					std::string description;
+					std::string receptionInstanceType;
+					std::string message;
+					std::string erRouteMapName;
+					std::string receptionInstanceId;
+					std::string gmtModified;
+					std::string erId;
+					std::string transmissionInstanceName;
+					std::string destinationCidrBlock;
+					std::string receptionInstanceOwner;
+					std::string tenantId;
+					std::string gmtCreate;
+					std::string receptionInstanceName;
+					std::string erRouteMapId;
+					std::string transmissionInstanceOwner;
+					std::string regionId;
+					std::string transmissionInstanceId;
+					int routeMapNum;
+				};
+
+
+				GetErRouteMapResult();
+				explicit GetErRouteMapResult(const std::string &payload);
+				~GetErRouteMapResult();
+				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_GETERROUTEMAPRESULT_H_

eflo/include/alibabacloud/eflo/model/GetFabricTopologyRequest.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_GETFABRICTOPOLOGYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETFABRICTOPOLOGYREQUEST_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 GetFabricTopologyRequest : public RpcServiceRequest {
+public:
+	GetFabricTopologyRequest();
+	~GetFabricTopologyRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+	std::vector<std::string> getLniIds() const;
+	void setLniIds(const std::vector<std::string> &lniIds);
+	std::vector<std::string> getNodeIds() const;
+	void setNodeIds(const std::vector<std::string> &nodeIds);
+
+private:
+	std::string regionId_;
+	std::string vpdId_;
+	std::vector<std::string> lniIds_;
+	std::vector<std::string> nodeIds_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETFABRICTOPOLOGYREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetFabricTopologyResult.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_GETFABRICTOPOLOGYRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETFABRICTOPOLOGYRESULT_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 GetFabricTopologyResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct Layer
+					{
+						std::string layerName;
+						std::vector<std::string> nextLayer;
+						std::string layerType;
+					};
+					std::string vpdId;
+					std::string regionId;
+					std::vector<Layer> topoInfo;
+				};
+
+
+				GetFabricTopologyResult();
+				explicit GetFabricTopologyResult(const std::string &payload);
+				~GetFabricTopologyResult();
+				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_GETFABRICTOPOLOGYRESULT_H_

eflo/include/alibabacloud/eflo/model/GetLniPrivateIpAddressRequest.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_GETLNIPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETLNIPRIVATEIPADDRESSREQUEST_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 GetLniPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	GetLniPrivateIpAddressRequest();
+	~GetLniPrivateIpAddressRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getIpName() const;
+	void setIpName(const std::string &ipName);
+	std::string getNetworkInterfaceId() const;
+	void setNetworkInterfaceId(const std::string &networkInterfaceId);
+
+private:
+	std::string regionId_;
+	std::string ipName_;
+	std::string networkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETLNIPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetLniPrivateIpAddressResult.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_GETLNIPRIVATEIPADDRESSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETLNIPRIVATEIPADDRESSRESULT_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 GetLniPrivateIpAddressResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string gmtCreate;
+					std::string ipName;
+					std::string privateIpAddress;
+					std::string description;
+					std::string ipAddressMac;
+					std::string message;
+					std::string regionId;
+					std::string networkInterfaceId;
+				};
+
+
+				GetLniPrivateIpAddressResult();
+				explicit GetLniPrivateIpAddressResult(const std::string &payload);
+				~GetLniPrivateIpAddressResult();
+				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_GETLNIPRIVATEIPADDRESSRESULT_H_

eflo/include/alibabacloud/eflo/model/GetNetworkInterfaceRequest.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_GETNETWORKINTERFACEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETNETWORKINTERFACEREQUEST_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 GetNetworkInterfaceRequest : public RpcServiceRequest {
+public:
+	GetNetworkInterfaceRequest();
+	~GetNetworkInterfaceRequest();
+	std::string getSubnetId() const;
+	void setSubnetId(const std::string &subnetId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNetworkInterfaceId() const;
+	void setNetworkInterfaceId(const std::string &networkInterfaceId);
+
+private:
+	std::string subnetId_;
+	std::string regionId_;
+	std::string networkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETNETWORKINTERFACEREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetNetworkInterfaceResult.h

@@ -0,0 +1,98 @@
+/*
+ * 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_GETNETWORKINTERFACERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETNETWORKINTERFACERESULT_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 GetNetworkInterfaceResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct VpdBaseInfo
+					{
+						std::string cidr;
+						std::string vpdId;
+						std::string createTime;
+						std::string vpdName;
+					};
+					struct SubnetBaseInfo
+					{
+						std::string subnetName;
+						std::string cidr;
+						std::string createTime;
+						std::string subnetId;
+					};
+					struct PrivateIpAddressMacGroupItem
+					{
+						std::string status;
+						std::string ipName;
+						std::string privateIpAddress;
+						std::string description;
+						std::string ipAddressMac;
+						std::string message;
+					};
+					std::string status;
+					VpdBaseInfo vpdBaseInfo;
+					std::string zoneId;
+					std::string ip;
+					std::string createTime;
+					std::string networkInterfaceName;
+					std::string networkInterfaceId;
+					std::string tenantId;
+					int quota;
+					std::string gateway;
+					std::vector<std::string> ethernet;
+					std::string nodeId;
+					SubnetBaseInfo subnetBaseInfo;
+					std::string serviceMac;
+					std::string ncType;
+					std::vector<PrivateIpAddressMacGroupItem> privateIpAddressMacGroup;
+					std::string regionId;
+				};
+
+
+				GetNetworkInterfaceResult();
+				explicit GetNetworkInterfaceResult(const std::string &payload);
+				~GetNetworkInterfaceResult();
+				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_GETNETWORKINTERFACERESULT_H_

eflo/include/alibabacloud/eflo/model/GetSubnetRequest.h

@@ -32,9 +32,15 @@ public:
 	~GetSubnetRequest();
 	std::string getSubnetId() const;
 	void setSubnetId(const std::string &subnetId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
 
 private:
 	std::string subnetId_;
+	std::string regionId_;
+	std::string vpdId_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/GetSubnetResult.h

@@ -36,28 +36,36 @@ namespace AlibabaCloud
 				{
 					struct VpdBaseInfo
 					{
-						std::string gmtCreate;
 						std::string cidr;
 						std::string vpdId;
-						std::string name;
+						std::string createTime;
+						std::string vpdName;
+					};
+					struct Tag
+					{
+						std::string tagKey;
+						std::string tagValue;
 					};
 					std::string status;
-					long ncCount;
+					int ncCount;
 					long lbCount;
+					int availableIps;
 					VpdBaseInfo vpdBaseInfo;
-					std::string description;
+					long privateIpCount;
 					std::string zoneId;
 					std::string message;
+					int networkInterfaceCount;
+					std::string resourceGroupId;
+					std::string createTime;
 					std::string gmtModified;
 					std::string subnetId;
-					std::string name;
-					std::string gmtCreate;
+					std::string subnetName;
 					std::string tenantId;
 					std::string type;
 					std::string cidr;
 					std::string vpdId;
-					long id;
 					std::string regionId;
+					std::vector<Tag> tags;
 				};
 
 

eflo/include/alibabacloud/eflo/model/GetVccGrantRuleRequest.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_GETVCCGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVCCGRANTRULEREQUEST_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 GetVccGrantRuleRequest : public RpcServiceRequest {
+public:
+	GetVccGrantRuleRequest();
+	~GetVccGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	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 regionId_;
+	std::string grantRuleId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETVCCGRANTRULEREQUEST_H_

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

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETVCCGRANTRULERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVCCGRANTRULERESULT_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 GetVccGrantRuleResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string instanceName;
+					std::string tenantId;
+					std::string grantTenantId;
+					std::string instanceId;
+					bool used;
+					std::string createTime;
+					std::string grantRuleId;
+					std::string product;
+					std::string erId;
+					std::string regionId;
+				};
+
+
+				GetVccGrantRuleResult();
+				explicit GetVccGrantRuleResult(const std::string &payload);
+				~GetVccGrantRuleResult();
+				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_GETVCCGRANTRULERESULT_H_

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

@@ -30,13 +30,22 @@ class ALIBABACLOUD_EFLO_EXPORT GetVccRequest : public RpcServiceRequest {
 public:
 	GetVccRequest();
 	~GetVccRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
 	std::string getVccId() const;
 	void setVccId(const std::string &vccId);
 
 private:
+	int pageNumber_;
 	std::string regionId_;
+	bool enablePage_;
+	int pageSize_;
 	std::string vccId_;
 };
 } // namespace Model

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

@@ -36,10 +36,25 @@ namespace AlibabaCloud
 				{
 					struct VpdBaseInfo
 					{
-						std::string gmtCreate;
 						std::string cidr;
 						std::string vpdId;
-						std::string name;
+						std::string createTime;
+						std::string vpdName;
+					};
+					struct ErInfo
+					{
+						std::string status;
+						long connections;
+						std::string erName;
+						std::string tenantId;
+						std::string description;
+						std::string message;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						std::string regionId;
+						long routeMaps;
+						std::string masterZoneId;
 					};
 					struct AliyunRouterInfoItem
 					{
@@ -64,7 +79,13 @@ namespace AlibabaCloud
 						std::string ccrId;
 						std::vector<CisRouterInfoItem::CcInfo> ccInfos;
 					};
+					struct Tag
+					{
+						std::string tagKey;
+						std::string tagValue;
+					};
 					std::string message;
+					std::string resourceGroupId;
 					std::string lineOperator;
 					std::string pricingCycle;
 					std::string currentNode;
@@ -72,8 +93,11 @@ namespace AlibabaCloud
 					std::string bgpCidr;
 					std::string commodityCode;
 					std::string vccId;
+					std::vector<Tag> tags;
 					std::string status;
 					VpdBaseInfo vpdBaseInfo;
+					std::string zoneId;
+					std::string connectionType;
 					std::string vSwitchId;
 					std::string createTime;
 					std::string duration;
@@ -84,7 +108,11 @@ namespace AlibabaCloud
 					std::vector<CisRouterInfoItem> cisRouterInfo;
 					std::string tenantId;
 					std::string vpcId;
+					std::string expirationDate;
 					std::string vpdId;
+					std::vector<ErInfo> erInfos;
+					std::string cenOwnerId;
+					bool attachErStatus;
 					std::string cenId;
 					std::string accessPointId;
 					std::string regionId;

eflo/include/alibabacloud/eflo/model/GetVccRouteEntryRequest.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_GETVCCROUTEENTRYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVCCROUTEENTRYREQUEST_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 GetVccRouteEntryRequest : public RpcServiceRequest {
+public:
+	GetVccRouteEntryRequest();
+	~GetVccRouteEntryRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVccId() const;
+	void setVccId(const std::string &vccId);
+	std::string getVccRouteEntryId() const;
+	void setVccRouteEntryId(const std::string &vccRouteEntryId);
+
+private:
+	std::string regionId_;
+	std::string vccId_;
+	std::string vccRouteEntryId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETVCCROUTEENTRYREQUEST_H_

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

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETVCCROUTEENTRYRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVCCROUTEENTRYRESULT_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 GetVccRouteEntryResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string vccRouteEntryId;
+					std::string nextHopType;
+					std::string tenantId;
+					std::string routeType;
+					std::string nextHopId;
+					std::string gmtModified;
+					std::string regionId;
+					std::string vccId;
+					std::string destinationCidrBlock;
+				};
+
+
+				GetVccRouteEntryResult();
+				explicit GetVccRouteEntryResult(const std::string &payload);
+				~GetVccRouteEntryResult();
+				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_GETVCCROUTEENTRYRESULT_H_

eflo/include/alibabacloud/eflo/model/GetVpdGrantRuleRequest.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_GETVPDGRANTRULEREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVPDGRANTRULEREQUEST_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 GetVpdGrantRuleRequest : public RpcServiceRequest {
+public:
+	GetVpdGrantRuleRequest();
+	~GetVpdGrantRuleRequest();
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	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 regionId_;
+	std::string grantRuleId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETVPDGRANTRULEREQUEST_H_

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

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETVPDGRANTRULERESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVPDGRANTRULERESULT_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 GetVpdGrantRuleResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string instanceName;
+					std::string tenantId;
+					std::string grantTenantId;
+					std::string instanceId;
+					bool used;
+					std::string createTime;
+					std::string grantRuleId;
+					std::string product;
+					std::string erId;
+					std::string regionId;
+				};
+
+
+				GetVpdGrantRuleResult();
+				explicit GetVpdGrantRuleResult(const std::string &payload);
+				~GetVpdGrantRuleResult();
+				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_GETVPDGRANTRULERESULT_H_

eflo/include/alibabacloud/eflo/model/GetVpdRequest.h

@@ -30,10 +30,13 @@ class ALIBABACLOUD_EFLO_EXPORT GetVpdRequest : public RpcServiceRequest {
 public:
 	GetVpdRequest();
 	~GetVpdRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	std::string getVpdId() const;
 	void setVpdId(const std::string &vpdId);
 
 private:
+	std::string regionId_;
 	std::string vpdId_;
 };
 } // namespace Model

eflo/include/alibabacloud/eflo/model/GetVpdResult.h

@@ -34,21 +34,46 @@ namespace AlibabaCloud
 			public:
 				struct Content
 				{
+					struct ErInfo
+					{
+						std::string status;
+						long connections;
+						std::string erName;
+						std::string tenantId;
+						std::string description;
+						std::string message;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						std::string regionId;
+						long routeMaps;
+						std::string masterZoneId;
+					};
+					struct Tag
+					{
+						std::string tagKey;
+						std::string tagValue;
+					};
 					std::string status;
-					long ncCount;
-					long lbCount;
-					std::string description;
+					int ncCount;
+					long privateIpCount;
 					std::string message;
+					int networkInterfaceCount;
 					long subnetCount;
+					std::string resourceGroupId;
+					std::vector<std::string> secondaryCidrBlocks;
+					std::string createTime;
 					std::string gmtModified;
-					std::string name;
-					std::string gmtCreate;
+					std::string vpdName;
+					std::string tenantId;
 					std::string cidr;
+					int quota;
 					std::string vpdId;
+					std::vector<ErInfo> erInfos;
+					bool attachErStatus;
 					std::string serviceCidr;
 					std::string regionId;
-					long vccCount;
-					int route;
+					std::vector<Tag> tags;
 				};
 
 

eflo/include/alibabacloud/eflo/model/GetVpdRouteEntryRequest.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_GETVPDROUTEENTRYREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVPDROUTEENTRYREQUEST_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 GetVpdRouteEntryRequest : public RpcServiceRequest {
+public:
+	GetVpdRouteEntryRequest();
+	~GetVpdRouteEntryRequest();
+	std::string getVpdRouteEntryId() const;
+	void setVpdRouteEntryId(const std::string &vpdRouteEntryId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+
+private:
+	std::string vpdRouteEntryId_;
+	std::string regionId_;
+	std::string vpdId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_GETVPDROUTEENTRYREQUEST_H_

eflo/include/alibabacloud/eflo/model/GetVpdRouteEntryResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_GETVPDROUTEENTRYRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_GETVPDROUTEENTRYRESULT_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 GetVpdRouteEntryResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					std::string status;
+					std::string nextHopType;
+					std::string tenantId;
+					std::string routeType;
+					std::string vpdId;
+					std::string nextHopId;
+					std::string gmtModified;
+					std::string regionId;
+					std::string destinationCidrBlock;
+					std::string vpdRouteEntryId;
+				};
+
+
+				GetVpdRouteEntryResult();
+				explicit GetVpdRouteEntryResult(const std::string &payload);
+				~GetVpdRouteEntryResult();
+				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_GETVPDROUTEENTRYRESULT_H_

eflo/include/alibabacloud/eflo/model/InitializeVccRequest.h

@@ -30,8 +30,11 @@ class ALIBABACLOUD_EFLO_EXPORT InitializeVccRequest : public RpcServiceRequest {
 public:
 	InitializeVccRequest();
 	~InitializeVccRequest();
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 
 private:
+	std::string resourceGroupId_;
 };
 } // namespace Model
 } // namespace Eflo

eflo/include/alibabacloud/eflo/model/ListElasticNetworkInterfacesRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTELASTICNETWORKINTERFACESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTELASTICNETWORKINTERFACESREQUEST_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 ListElasticNetworkInterfacesRequest : public RpcServiceRequest {
+public:
+	ListElasticNetworkInterfacesRequest();
+	~ListElasticNetworkInterfacesRequest();
+	std::string getNetworkType() const;
+	void setNetworkType(const std::string &networkType);
+	std::string getType() const;
+	void setType(const std::string &type);
+	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 getNodeId() const;
+	void setNodeId(const std::string &nodeId);
+	std::string getIp() const;
+	void setIp(const std::string &ip);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getElasticNetworkInterfaceId() const;
+	void setElasticNetworkInterfaceId(const std::string &elasticNetworkInterfaceId);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string networkType_;
+	std::string type_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+	std::string nodeId_;
+	std::string ip_;
+	std::string vSwitchId_;
+	std::string vpcId_;
+	std::string zoneId_;
+	std::string elasticNetworkInterfaceId_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTELASTICNETWORKINTERFACESREQUEST_H_

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

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTELASTICNETWORKINTERFACESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTELASTICNETWORKINTERFACESRESULT_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 ListElasticNetworkInterfacesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string description;
+						std::string zoneId;
+						std::string message;
+						std::string ip;
+						std::string vSwitchId;
+						std::string createTime;
+						std::string mask;
+						std::string gmtModified;
+						std::string mac;
+						std::string elasticNetworkInterfaceId;
+						std::string type;
+						std::string vpcId;
+						std::string gateway;
+						std::string nodeId;
+						std::string regionId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListElasticNetworkInterfacesResult();
+				explicit ListElasticNetworkInterfacesResult(const std::string &payload);
+				~ListElasticNetworkInterfacesResult();
+				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_LISTELASTICNETWORKINTERFACESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListErAttachmentsRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTERATTACHMENTSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERATTACHMENTSREQUEST_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 ListErAttachmentsRequest : public RpcServiceRequest {
+public:
+	ListErAttachmentsRequest();
+	~ListErAttachmentsRequest();
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getResourceTenantId() const;
+	void setResourceTenantId(const std::string &resourceTenantId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getAutoReceiveAllRoute() const;
+	void setAutoReceiveAllRoute(bool autoReceiveAllRoute);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getErAttachmentName() const;
+	void setErAttachmentName(const std::string &erAttachmentName);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getErAttachmentId() const;
+	void setErAttachmentId(const std::string &erAttachmentId);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	int pageNumber_;
+	std::string resourceTenantId_;
+	std::string regionId_;
+	bool autoReceiveAllRoute_;
+	int pageSize_;
+	std::string instanceType_;
+	std::string erAttachmentName_;
+	std::string erId_;
+	std::string instanceId_;
+	std::string erAttachmentId_;
+	bool enablePage_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTERATTACHMENTSREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListErAttachmentsResult.h

@@ -0,0 +1,78 @@
+/*
+ * 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_LISTERATTACHMENTSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERATTACHMENTSRESULT_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 ListErAttachmentsResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string message;
+						std::string instanceId;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						bool across;
+						std::string instanceName;
+						std::string tenantId;
+						std::string resourceTenantId;
+						bool autoReceiveAllRoute;
+						std::string erAttachmentName;
+						std::string erAttachmentId;
+						std::string regionId;
+						std::string instanceType;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListErAttachmentsResult();
+				explicit ListErAttachmentsResult(const std::string &payload);
+				~ListErAttachmentsResult();
+				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_LISTERATTACHMENTSRESULT_H_

eflo/include/alibabacloud/eflo/model/ListErRouteEntriesRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTERROUTEENTRIESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERROUTEENTRIESREQUEST_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 ListErRouteEntriesRequest : public RpcServiceRequest {
+public:
+	ListErRouteEntriesRequest();
+	~ListErRouteEntriesRequest();
+	bool getIgnoreDetailedRouteEntry() const;
+	void setIgnoreDetailedRouteEntry(bool ignoreDetailedRouteEntry);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRouteType() const;
+	void setRouteType(const std::string &routeType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getNextHopId() const;
+	void setNextHopId(const std::string &nextHopId);
+	std::string getNextHopType() const;
+	void setNextHopType(const std::string &nextHopType);
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	bool ignoreDetailedRouteEntry_;
+	int pageNumber_;
+	std::string routeType_;
+	std::string regionId_;
+	int pageSize_;
+	std::string nextHopId_;
+	std::string nextHopType_;
+	std::string destinationCidrBlock_;
+	std::string erId_;
+	std::string instanceId_;
+	bool enablePage_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTERROUTEENTRIESREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListErRouteEntriesResult.h

@@ -0,0 +1,74 @@
+/*
+ * 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_LISTERROUTEENTRIESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERROUTEENTRIESRESULT_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 ListErRouteEntriesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string nextHopType;
+						std::string tenantId;
+						std::string resourceTenantId;
+						std::string routeType;
+						std::string erRouteEntryId;
+						std::string nextHopId;
+						std::string gmtModified;
+						std::string erId;
+						std::string regionId;
+						std::string destinationCidrBlock;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListErRouteEntriesResult();
+				explicit ListErRouteEntriesResult(const std::string &payload);
+				~ListErRouteEntriesResult();
+				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_LISTERROUTEENTRIESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListErRouteMapsRequest.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTERROUTEMAPSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERROUTEMAPSREQUEST_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 ListErRouteMapsRequest : public RpcServiceRequest {
+public:
+	ListErRouteMapsRequest();
+	~ListErRouteMapsRequest();
+	std::string getReceptionInstanceType() const;
+	void setReceptionInstanceType(const std::string &receptionInstanceType);
+	std::string getReceptionInstanceId() const;
+	void setReceptionInstanceId(const std::string &receptionInstanceId);
+	int getErRouteMapNum() const;
+	void setErRouteMapNum(int erRouteMapNum);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRouteMapAction() const;
+	void setRouteMapAction(const std::string &routeMapAction);
+	std::string getTransmissionInstanceType() const;
+	void setTransmissionInstanceType(const std::string &transmissionInstanceType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getTransmissionInstanceName() const;
+	void setTransmissionInstanceName(const std::string &transmissionInstanceName);
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getErRouteMapId() const;
+	void setErRouteMapId(const std::string &erRouteMapId);
+	std::string getReceptionInstanceName() const;
+	void setReceptionInstanceName(const std::string &receptionInstanceName);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getTransmissionInstanceId() const;
+	void setTransmissionInstanceId(const std::string &transmissionInstanceId);
+
+private:
+	std::string receptionInstanceType_;
+	std::string receptionInstanceId_;
+	int erRouteMapNum_;
+	int pageNumber_;
+	std::string routeMapAction_;
+	std::string transmissionInstanceType_;
+	std::string regionId_;
+	int pageSize_;
+	std::string transmissionInstanceName_;
+	std::string destinationCidrBlock_;
+	std::string erId_;
+	std::string erRouteMapId_;
+	std::string receptionInstanceName_;
+	bool enablePage_;
+	std::string transmissionInstanceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTERROUTEMAPSREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListErRouteMapsResult.h

@@ -0,0 +1,83 @@
+/*
+ * 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_LISTERROUTEMAPSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERROUTEMAPSRESULT_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 ListErRouteMapsResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string transmissionInstanceType;
+						std::string action;
+						std::string description;
+						std::string receptionInstanceType;
+						std::string message;
+						std::string receptionInstanceId;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						std::string transmissionInstanceName;
+						std::string destinationCidrBlock;
+						std::string receptionInstanceOwner;
+						std::string tenantId;
+						std::string receptionInstanceName;
+						std::string erRouteMapId;
+						std::string transmissionInstanceOwner;
+						std::string regionId;
+						std::string transmissionInstanceId;
+						int routeMapNum;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListErRouteMapsResult();
+				explicit ListErRouteMapsResult(const std::string &payload);
+				~ListErRouteMapsResult();
+				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_LISTERROUTEMAPSRESULT_H_

eflo/include/alibabacloud/eflo/model/ListErsRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTERSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERSREQUEST_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 ListErsRequest : public RpcServiceRequest {
+public:
+	ListErsRequest();
+	~ListErsRequest();
+	std::string getMasterZoneId() const;
+	void setMasterZoneId(const std::string &masterZoneId);
+	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 getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	std::string getErName() const;
+	void setErName(const std::string &erName);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+
+private:
+	std::string masterZoneId_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+	std::string instanceType_;
+	std::string erId_;
+	std::string erName_;
+	std::string instanceId_;
+	bool enablePage_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTERSREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListErsResult.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTERSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTERSRESULT_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 ListErsResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						long connections;
+						std::string erName;
+						std::string tenantId;
+						std::string description;
+						std::string message;
+						std::string createTime;
+						std::string gmtModified;
+						std::string erId;
+						std::string regionId;
+						long routeMaps;
+						std::string masterZoneId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListErsResult();
+				explicit ListErsResult(const std::string &payload);
+				~ListErsResult();
+				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_LISTERSRESULT_H_

eflo/include/alibabacloud/eflo/model/ListInstancesByNcdRequest.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_LISTINSTANCESBYNCDREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTINSTANCESBYNCDREQUEST_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 ListInstancesByNcdRequest : public RpcServiceRequest {
+public:
+	ListInstancesByNcdRequest();
+	~ListInstancesByNcdRequest();
+	int getMaxNcd() const;
+	void setMaxNcd(int maxNcd);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+
+private:
+	int maxNcd_;
+	std::string instanceId_;
+	std::string regionId_;
+	std::string instanceType_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTINSTANCESBYNCDREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListInstancesByNcdResult.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_LISTINSTANCESBYNCDRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTINSTANCESBYNCDRESULT_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 ListInstancesByNcdResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct InstanceInfo
+					{
+						std::string instanceId;
+						int ncd;
+					};
+					int maxNcd;
+					std::string instanceType;
+					std::string sourceInstanceId;
+					std::vector<InstanceInfo> instanceInfos;
+				};
+
+
+				ListInstancesByNcdResult();
+				explicit ListInstancesByNcdResult(const std::string &payload);
+				~ListInstancesByNcdResult();
+				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_LISTINSTANCESBYNCDRESULT_H_

eflo/include/alibabacloud/eflo/model/ListLniPrivateIpAddressRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTLNIPRIVATEIPADDRESSREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTLNIPRIVATEIPADDRESSREQUEST_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 ListLniPrivateIpAddressRequest : public RpcServiceRequest {
+public:
+	ListLniPrivateIpAddressRequest();
+	~ListLniPrivateIpAddressRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	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 getIp() const;
+	void setIp(const std::string &ip);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getIpName() const;
+	void setIpName(const std::string &ipName);
+	std::string getNetworkInterfaceId() const;
+	void setNetworkInterfaceId(const std::string &networkInterfaceId);
+
+private:
+	std::string description_;
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+	std::string ip_;
+	bool enablePage_;
+	std::string ipName_;
+	std::string networkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTLNIPRIVATEIPADDRESSREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListLniPrivateIpAddressResult.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_LISTLNIPRIVATEIPADDRESSRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTLNIPRIVATEIPADDRESSRESULT_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 ListLniPrivateIpAddressResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string gmtCreate;
+						std::string ipName;
+						std::string privateIpAddress;
+						std::string description;
+						std::string ipAddressMac;
+						std::string message;
+						std::string regionId;
+						std::string networkInterfaceId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListLniPrivateIpAddressResult();
+				explicit ListLniPrivateIpAddressResult(const std::string &payload);
+				~ListLniPrivateIpAddressResult();
+				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_LISTLNIPRIVATEIPADDRESSRESULT_H_

eflo/include/alibabacloud/eflo/model/ListNetworkInterfacesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTNETWORKINTERFACESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTNETWORKINTERFACESREQUEST_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 ListNetworkInterfacesRequest : public RpcServiceRequest {
+public:
+	ListNetworkInterfacesRequest();
+	~ListNetworkInterfacesRequest();
+	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 getNodeId() const;
+	void setNodeId(const std::string &nodeId);
+	std::string getSubnetId() const;
+	void setSubnetId(const std::string &subnetId);
+	std::string getIp() const;
+	void setIp(const std::string &ip);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getNetworkInterfaceId() const;
+	void setNetworkInterfaceId(const std::string &networkInterfaceId);
+
+private:
+	int pageNumber_;
+	std::string regionId_;
+	int pageSize_;
+	std::string nodeId_;
+	std::string subnetId_;
+	std::string ip_;
+	std::string vpdId_;
+	bool enablePage_;
+	std::string networkInterfaceId_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTNETWORKINTERFACESREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListNetworkInterfacesResult.h

@@ -0,0 +1,103 @@
+/*
+ * 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_LISTNETWORKINTERFACESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTNETWORKINTERFACESRESULT_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 ListNetworkInterfacesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						struct VpdBaseInfo
+						{
+							std::string cidr;
+							std::string vpdId;
+							std::string createTime;
+							std::string vpdName;
+						};
+						struct SubnetBaseInfo
+						{
+							std::string subnetName;
+							std::string cidr;
+							std::string createTime;
+							std::string subnetId;
+						};
+						struct PrivateIpAddressMacGroupItem
+						{
+							std::string status;
+							std::string ipName;
+							std::string privateIpAddress;
+							std::string description;
+							std::string ipAddressMac;
+							std::string message;
+						};
+						std::string status;
+						VpdBaseInfo vpdBaseInfo;
+						std::string zoneId;
+						std::string ip;
+						std::string createTime;
+						std::string networkInterfaceName;
+						std::string networkInterfaceId;
+						std::string tenantId;
+						int quota;
+						std::string gateway;
+						std::vector<std::string> ethernet;
+						std::string nodeId;
+						SubnetBaseInfo subnetBaseInfo;
+						std::string serviceMac;
+						std::string ncType;
+						std::vector<DataItem::PrivateIpAddressMacGroupItem> privateIpAddressMacGroup;
+						std::string regionId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListNetworkInterfacesResult();
+				explicit ListNetworkInterfacesResult(const std::string &payload);
+				~ListNetworkInterfacesResult();
+				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_LISTNETWORKINTERFACESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListSubnetsRequest.h

@@ -28,39 +28,49 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT ListSubnetsRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	ListSubnetsRequest();
 	~ListSubnetsRequest();
 	std::string getType() const;
 	void setType(const std::string &type);
 	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);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getSubnetId() const;
 	void setSubnetId(const std::string &subnetId);
 	std::string getVpdId() const;
 	void setVpdId(const std::string &vpdId);
 	bool getEnablePage() const;
 	void setEnablePage(bool enablePage);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getZoneId() const;
 	void setZoneId(const std::string &zoneId);
+	std::string getSubnetName() const;
+	void setSubnetName(const std::string &subnetName);
 	std::string getStatus() const;
 	void setStatus(const std::string &status);
 
 private:
 	std::string type_;
 	int pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	int pageSize_;
+	std::vector<Tag> tag_;
 	std::string subnetId_;
 	std::string vpdId_;
 	bool enablePage_;
-	std::string name_;
 	std::string zoneId_;
+	std::string subnetName_;
 	std::string status_;
 };
 } // namespace Model

eflo/include/alibabacloud/eflo/model/ListSubnetsResult.h

@@ -38,26 +38,33 @@ namespace AlibabaCloud
 					{
 						struct VpdBaseInfo
 						{
-							std::string gmtCreate;
 							std::string cidr;
 							std::string vpdId;
-							std::string name;
+							std::string createTime;
+							std::string vpdName;
+						};
+						struct Tag
+						{
+							std::string tagKey;
+							std::string tagValue;
 						};
 						std::string status;
-						long ncCount;
+						int ncCount;
 						VpdBaseInfo vpdBaseInfo;
 						std::string zoneId;
 						std::string message;
+						int networkInterfaceCount;
+						std::string resourceGroupId;
+						std::string createTime;
 						std::string gmtModified;
 						std::string subnetId;
-						std::string name;
-						std::string gmtCreate;
+						std::string subnetName;
 						std::string tenantId;
 						std::string type;
 						std::string cidr;
 						std::string vpdId;
-						long id;
 						std::string regionId;
+						std::vector<DataItem::Tag> tags;
 					};
 					long total;
 					std::vector<DataItem> data;

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVCCGRANTRULESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVCCGRANTRULESREQUEST_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 ListVccGrantRulesRequest : public RpcServiceRequest {
+public:
+	ListVccGrantRulesRequest();
+	~ListVccGrantRulesRequest();
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getGrantRuleId() const;
+	void setGrantRuleId(const std::string &grantRuleId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	bool getForSelect() const;
+	void setForSelect(bool forSelect);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getInstanceName() const;
+	void setInstanceName(const std::string &instanceName);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+
+private:
+	std::string grantTenantId_;
+	int pageNumber_;
+	std::string regionId_;
+	std::string grantRuleId_;
+	int pageSize_;
+	std::string erId_;
+	bool forSelect_;
+	std::string instanceId_;
+	std::string instanceName_;
+	bool enablePage_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVCCGRANTRULESREQUEST_H_

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVCCGRANTRULESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVCCGRANTRULESRESULT_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 ListVccGrantRulesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string instanceName;
+						std::string tenantId;
+						std::string grantTenantId;
+						std::string instanceId;
+						bool used;
+						std::string createTime;
+						std::string grantRuleId;
+						std::string product;
+						std::string erId;
+						std::string regionId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListVccGrantRulesResult();
+				explicit ListVccGrantRulesResult(const std::string &payload);
+				~ListVccGrantRulesResult();
+				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_LISTVCCGRANTRULESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListVccRouteEntriesRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVCCROUTEENTRIESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVCCROUTEENTRIESREQUEST_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 ListVccRouteEntriesRequest : public RpcServiceRequest {
+public:
+	ListVccRouteEntriesRequest();
+	~ListVccRouteEntriesRequest();
+	bool getIgnoreDetailedRouteEntry() const;
+	void setIgnoreDetailedRouteEntry(bool ignoreDetailedRouteEntry);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRouteType() const;
+	void setRouteType(const std::string &routeType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getNextHopId() const;
+	void setNextHopId(const std::string &nextHopId);
+	std::string getVccId() const;
+	void setVccId(const std::string &vccId);
+	std::string getNextHopType() const;
+	void setNextHopType(const std::string &nextHopType);
+	std::string getVpdRouteEntryId() const;
+	void setVpdRouteEntryId(const std::string &vpdRouteEntryId);
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	bool ignoreDetailedRouteEntry_;
+	int pageNumber_;
+	std::string routeType_;
+	std::string regionId_;
+	int pageSize_;
+	std::string nextHopId_;
+	std::string vccId_;
+	std::string nextHopType_;
+	std::string vpdRouteEntryId_;
+	std::string destinationCidrBlock_;
+	bool enablePage_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVCCROUTEENTRIESREQUEST_H_

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

@@ -0,0 +1,74 @@
+/*
+ * 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_LISTVCCROUTEENTRIESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVCCROUTEENTRIESRESULT_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 ListVccRouteEntriesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string vccRouteEntryId;
+						std::string nextHopType;
+						std::string tenantId;
+						std::string resourceTenantId;
+						std::string routeType;
+						std::string nextHopId;
+						std::string gmtModified;
+						std::string vccId;
+						std::string regionId;
+						std::string destinationCidrBlock;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListVccRouteEntriesResult();
+				explicit ListVccRouteEntriesResult(const std::string &payload);
+				~ListVccRouteEntriesResult();
+				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_LISTVCCROUTEENTRIESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListVccsRequest.h

@@ -28,22 +28,32 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT ListVccsRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	ListVccsRequest();
 	~ListVccsRequest();
 	std::string getCenId() const;
 	void setCenId(const std::string &cenId);
 	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);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	std::string getVccId() const;
 	void setVccId(const std::string &vccId);
 	int getBandwidth() const;
 	void setBandwidth(int bandwidth);
 	std::string getExStatus() const;
 	void setExStatus(const std::string &exStatus);
+	std::string getFilterErId() const;
+	void setFilterErId(const std::string &filterErId);
 	std::string getVpdId() const;
 	void setVpdId(const std::string &vpdId);
 	std::string getVpcId() const;
@@ -56,11 +66,14 @@ public:
 private:
 	std::string cenId_;
 	int pageNumber_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	int pageSize_;
+	std::vector<Tag> tag_;
 	std::string vccId_;
 	int bandwidth_;
 	std::string exStatus_;
+	std::string filterErId_;
 	std::string vpdId_;
 	std::string vpcId_;
 	bool enablePage_;

eflo/include/alibabacloud/eflo/model/ListVccsResult.h

@@ -38,27 +38,57 @@ namespace AlibabaCloud
 					{
 						struct VpdBaseInfo
 						{
-							std::string gmtCreate;
 							std::string cidr;
 							std::string vpdId;
-							std::string name;
+							std::string createTime;
+							std::string vpdName;
 						};
-						std::string status;
-						VpdBaseInfo vpdBaseInfo;
+						struct ErInfo
+						{
+							std::string status;
+							long connections;
+							std::string erName;
+							std::string tenantId;
+							std::string description;
+							std::string message;
+							std::string createTime;
+							std::string gmtModified;
+							std::string erId;
+							std::string regionId;
+							long routeMaps;
+							std::string masterZoneId;
+						};
+						struct Tag
+						{
+							std::string tagKey;
+							std::string tagValue;
+						};
+						std::string taskId;
 						std::string message;
+						std::string resourceGroupId;
 						std::string lineOperator;
+						std::string currentNode;
+						std::string gmtModified;
+						std::string bgpCidr;
+						std::string commodityCode;
+						std::string vccId;
+						std::vector<DataItem::Tag> tags;
+						std::string status;
+						VpdBaseInfo vpdBaseInfo;
+						std::string zoneId;
+						std::string connectionType;
 						double rate;
 						std::string createTime;
-						std::string gmtModified;
 						std::string bandwidthStr;
 						std::string tenantId;
 						std::string vpcId;
+						std::string expirationDate;
 						std::string vpdId;
-						std::string bgpCidr;
+						std::vector<DataItem::ErInfo> erInfos;
+						std::string cenOwnerId;
 						std::string cenId;
 						std::string accessPointId;
 						std::string regionId;
-						std::string vccId;
 						std::string spec;
 						std::string vccName;
 						std::string portType;

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVPDGRANTRULESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVPDGRANTRULESREQUEST_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 ListVpdGrantRulesRequest : public RpcServiceRequest {
+public:
+	ListVpdGrantRulesRequest();
+	~ListVpdGrantRulesRequest();
+	std::string getGrantTenantId() const;
+	void setGrantTenantId(const std::string &grantTenantId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getGrantRuleId() const;
+	void setGrantRuleId(const std::string &grantRuleId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getErId() const;
+	void setErId(const std::string &erId);
+	bool getForSelect() const;
+	void setForSelect(bool forSelect);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getInstanceName() const;
+	void setInstanceName(const std::string &instanceName);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+
+private:
+	std::string grantTenantId_;
+	int pageNumber_;
+	std::string regionId_;
+	std::string grantRuleId_;
+	int pageSize_;
+	std::string erId_;
+	bool forSelect_;
+	std::string instanceId_;
+	std::string instanceName_;
+	bool enablePage_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVPDGRANTRULESREQUEST_H_

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVPDGRANTRULESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVPDGRANTRULESRESULT_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 ListVpdGrantRulesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string instanceName;
+						std::string tenantId;
+						std::string grantTenantId;
+						std::string instanceId;
+						bool used;
+						std::string createTime;
+						std::string grantRuleId;
+						std::string product;
+						std::string erId;
+						std::string regionId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListVpdGrantRulesResult();
+				explicit ListVpdGrantRulesResult(const std::string &payload);
+				~ListVpdGrantRulesResult();
+				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_LISTVPDGRANTRULESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListVpdRouteEntriesRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EFLO_MODEL_LISTVPDROUTEENTRIESREQUEST_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVPDROUTEENTRIESREQUEST_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 ListVpdRouteEntriesRequest : public RpcServiceRequest {
+public:
+	ListVpdRouteEntriesRequest();
+	~ListVpdRouteEntriesRequest();
+	bool getIgnoreDetailedRouteEntry() const;
+	void setIgnoreDetailedRouteEntry(bool ignoreDetailedRouteEntry);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRouteType() const;
+	void setRouteType(const std::string &routeType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getNextHopId() const;
+	void setNextHopId(const std::string &nextHopId);
+	std::string getNextHopType() const;
+	void setNextHopType(const std::string &nextHopType);
+	std::string getVpdRouteEntryId() const;
+	void setVpdRouteEntryId(const std::string &vpdRouteEntryId);
+	std::string getDestinationCidrBlock() const;
+	void setDestinationCidrBlock(const std::string &destinationCidrBlock);
+	std::string getVpdId() const;
+	void setVpdId(const std::string &vpdId);
+	bool getEnablePage() const;
+	void setEnablePage(bool enablePage);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	bool ignoreDetailedRouteEntry_;
+	int pageNumber_;
+	std::string routeType_;
+	std::string regionId_;
+	int pageSize_;
+	std::string nextHopId_;
+	std::string nextHopType_;
+	std::string vpdRouteEntryId_;
+	std::string destinationCidrBlock_;
+	std::string vpdId_;
+	bool enablePage_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Eflo
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EFLO_MODEL_LISTVPDROUTEENTRIESREQUEST_H_

eflo/include/alibabacloud/eflo/model/ListVpdRouteEntriesResult.h

@@ -0,0 +1,74 @@
+/*
+ * 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_LISTVPDROUTEENTRIESRESULT_H_
+#define ALIBABACLOUD_EFLO_MODEL_LISTVPDROUTEENTRIESRESULT_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 ListVpdRouteEntriesResult : public ServiceResult
+			{
+			public:
+				struct Content
+				{
+					struct DataItem
+					{
+						std::string status;
+						std::string nextHopType;
+						std::string tenantId;
+						std::string resourceTenantId;
+						std::string routeType;
+						std::string vpdId;
+						std::string nextHopId;
+						std::string gmtModified;
+						std::string regionId;
+						std::string destinationCidrBlock;
+						std::string vpdRouteEntryId;
+					};
+					long total;
+					std::vector<DataItem> data;
+				};
+
+
+				ListVpdRouteEntriesResult();
+				explicit ListVpdRouteEntriesResult(const std::string &payload);
+				~ListVpdRouteEntriesResult();
+				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_LISTVPDROUTEENTRIESRESULT_H_

eflo/include/alibabacloud/eflo/model/ListVpdsRequest.h

@@ -28,18 +28,28 @@ namespace Eflo {
 namespace Model {
 class ALIBABACLOUD_EFLO_EXPORT ListVpdsRequest : public RpcServiceRequest {
 public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
 	ListVpdsRequest();
 	~ListVpdsRequest();
+	std::string getVpdName() const;
+	void setVpdName(const std::string &vpdName);
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
 	bool getWithDependence() const;
 	void setWithDependence(bool withDependence);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	bool getWithoutVcc() const;
 	void setWithoutVcc(bool withoutVcc);
 	int getPageSize() const;
 	void setPageSize(int pageSize);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	bool getForSelect() const;
 	void setForSelect(bool forSelect);
 	std::string getFilterErId() const;
@@ -48,22 +58,22 @@ public:
 	void setVpdId(const std::string &vpdId);
 	bool getEnablePage() const;
 	void setEnablePage(bool enablePage);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getStatus() const;
 	void setStatus(const std::string &status);
 
 private:
+	std::string vpdName_;
 	int pageNumber_;
 	bool withDependence_;
+	std::string resourceGroupId_;
 	std::string regionId_;
 	bool withoutVcc_;
 	int pageSize_;
+	std::vector<Tag> tag_;
 	bool forSelect_;
 	std::string filterErId_;
 	std::string vpdId_;
 	bool enablePage_;
-	std::string name_;
 	std::string status_;
 };
 } // namespace Model