Support Snapshot API.

VERSION

@@ -1 +1 @@
-1.36.1401
+1.36.1402

ens/CMakeLists.txt

@@ -239,6 +239,8 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/DescribeMeasurementDataResult.h
 	include/alibabacloud/ens/model/DescribeMountTargetsRequest.h
 	include/alibabacloud/ens/model/DescribeMountTargetsResult.h
+	include/alibabacloud/ens/model/DescribeNCInformationRequest.h
+	include/alibabacloud/ens/model/DescribeNCInformationResult.h
 	include/alibabacloud/ens/model/DescribeNatGatewaysRequest.h
 	include/alibabacloud/ens/model/DescribeNatGatewaysResult.h
 	include/alibabacloud/ens/model/DescribeNetworkAclsRequest.h
@@ -255,8 +257,12 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/DescribePriceResult.h
 	include/alibabacloud/ens/model/DescribeRegionIspsRequest.h
 	include/alibabacloud/ens/model/DescribeRegionIspsResult.h
+	include/alibabacloud/ens/model/DescribeRegionResourceRequest.h
+	include/alibabacloud/ens/model/DescribeRegionResourceResult.h
 	include/alibabacloud/ens/model/DescribeReservedResourceRequest.h
 	include/alibabacloud/ens/model/DescribeReservedResourceResult.h
+	include/alibabacloud/ens/model/DescribeResourceTimelineRequest.h
+	include/alibabacloud/ens/model/DescribeResourceTimelineResult.h
 	include/alibabacloud/ens/model/DescribeSecurityGroupAttributeRequest.h
 	include/alibabacloud/ens/model/DescribeSecurityGroupAttributeResult.h
 	include/alibabacloud/ens/model/DescribeSecurityGroupsRequest.h
@@ -335,8 +341,12 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/RebootARMServerInstanceResult.h
 	include/alibabacloud/ens/model/RebootInstanceRequest.h
 	include/alibabacloud/ens/model/RebootInstanceResult.h
+	include/alibabacloud/ens/model/RebootInstancesRequest.h
+	include/alibabacloud/ens/model/RebootInstancesResult.h
 	include/alibabacloud/ens/model/ReinitInstanceRequest.h
 	include/alibabacloud/ens/model/ReinitInstanceResult.h
+	include/alibabacloud/ens/model/ReinitInstancesRequest.h
+	include/alibabacloud/ens/model/ReinitInstancesResult.h
 	include/alibabacloud/ens/model/ReleaseARMServerInstanceRequest.h
 	include/alibabacloud/ens/model/ReleaseARMServerInstanceResult.h
 	include/alibabacloud/ens/model/ReleaseInstanceRequest.h
@@ -393,12 +403,16 @@ set(ens_public_header_model
 	include/alibabacloud/ens/model/StartEpnInstanceResult.h
 	include/alibabacloud/ens/model/StartInstanceRequest.h
 	include/alibabacloud/ens/model/StartInstanceResult.h
+	include/alibabacloud/ens/model/StartInstancesRequest.h
+	include/alibabacloud/ens/model/StartInstancesResult.h
 	include/alibabacloud/ens/model/StartLoadBalancerListenerRequest.h
 	include/alibabacloud/ens/model/StartLoadBalancerListenerResult.h
 	include/alibabacloud/ens/model/StopEpnInstanceRequest.h
 	include/alibabacloud/ens/model/StopEpnInstanceResult.h
 	include/alibabacloud/ens/model/StopInstanceRequest.h
 	include/alibabacloud/ens/model/StopInstanceResult.h
+	include/alibabacloud/ens/model/StopInstancesRequest.h
+	include/alibabacloud/ens/model/StopInstancesResult.h
 	include/alibabacloud/ens/model/StopLoadBalancerListenerRequest.h
 	include/alibabacloud/ens/model/StopLoadBalancerListenerResult.h
 	include/alibabacloud/ens/model/UnAssociateEnsEipAddressRequest.h
@@ -632,6 +646,8 @@ set(ens_src
 	src/model/DescribeMeasurementDataResult.cc
 	src/model/DescribeMountTargetsRequest.cc
 	src/model/DescribeMountTargetsResult.cc
+	src/model/DescribeNCInformationRequest.cc
+	src/model/DescribeNCInformationResult.cc
 	src/model/DescribeNatGatewaysRequest.cc
 	src/model/DescribeNatGatewaysResult.cc
 	src/model/DescribeNetworkAclsRequest.cc
@@ -648,8 +664,12 @@ set(ens_src
 	src/model/DescribePriceResult.cc
 	src/model/DescribeRegionIspsRequest.cc
 	src/model/DescribeRegionIspsResult.cc
+	src/model/DescribeRegionResourceRequest.cc
+	src/model/DescribeRegionResourceResult.cc
 	src/model/DescribeReservedResourceRequest.cc
 	src/model/DescribeReservedResourceResult.cc
+	src/model/DescribeResourceTimelineRequest.cc
+	src/model/DescribeResourceTimelineResult.cc
 	src/model/DescribeSecurityGroupAttributeRequest.cc
 	src/model/DescribeSecurityGroupAttributeResult.cc
 	src/model/DescribeSecurityGroupsRequest.cc
@@ -728,8 +748,12 @@ set(ens_src
 	src/model/RebootARMServerInstanceResult.cc
 	src/model/RebootInstanceRequest.cc
 	src/model/RebootInstanceResult.cc
+	src/model/RebootInstancesRequest.cc
+	src/model/RebootInstancesResult.cc
 	src/model/ReinitInstanceRequest.cc
 	src/model/ReinitInstanceResult.cc
+	src/model/ReinitInstancesRequest.cc
+	src/model/ReinitInstancesResult.cc
 	src/model/ReleaseARMServerInstanceRequest.cc
 	src/model/ReleaseARMServerInstanceResult.cc
 	src/model/ReleaseInstanceRequest.cc
@@ -786,12 +810,16 @@ set(ens_src
 	src/model/StartEpnInstanceResult.cc
 	src/model/StartInstanceRequest.cc
 	src/model/StartInstanceResult.cc
+	src/model/StartInstancesRequest.cc
+	src/model/StartInstancesResult.cc
 	src/model/StartLoadBalancerListenerRequest.cc
 	src/model/StartLoadBalancerListenerResult.cc
 	src/model/StopEpnInstanceRequest.cc
 	src/model/StopEpnInstanceResult.cc
 	src/model/StopInstanceRequest.cc
 	src/model/StopInstanceResult.cc
+	src/model/StopInstancesRequest.cc
+	src/model/StopInstancesResult.cc
 	src/model/StopLoadBalancerListenerRequest.cc
 	src/model/StopLoadBalancerListenerResult.cc
 	src/model/UnAssociateEnsEipAddressRequest.cc

ens/include/alibabacloud/ens/EnsClient.h

@@ -240,6 +240,8 @@
 #include "model/DescribeMeasurementDataResult.h"
 #include "model/DescribeMountTargetsRequest.h"
 #include "model/DescribeMountTargetsResult.h"
+#include "model/DescribeNCInformationRequest.h"
+#include "model/DescribeNCInformationResult.h"
 #include "model/DescribeNatGatewaysRequest.h"
 #include "model/DescribeNatGatewaysResult.h"
 #include "model/DescribeNetworkAclsRequest.h"
@@ -256,8 +258,12 @@
 #include "model/DescribePriceResult.h"
 #include "model/DescribeRegionIspsRequest.h"
 #include "model/DescribeRegionIspsResult.h"
+#include "model/DescribeRegionResourceRequest.h"
+#include "model/DescribeRegionResourceResult.h"
 #include "model/DescribeReservedResourceRequest.h"
 #include "model/DescribeReservedResourceResult.h"
+#include "model/DescribeResourceTimelineRequest.h"
+#include "model/DescribeResourceTimelineResult.h"
 #include "model/DescribeSecurityGroupAttributeRequest.h"
 #include "model/DescribeSecurityGroupAttributeResult.h"
 #include "model/DescribeSecurityGroupsRequest.h"
@@ -336,8 +342,12 @@
 #include "model/RebootARMServerInstanceResult.h"
 #include "model/RebootInstanceRequest.h"
 #include "model/RebootInstanceResult.h"
+#include "model/RebootInstancesRequest.h"
+#include "model/RebootInstancesResult.h"
 #include "model/ReinitInstanceRequest.h"
 #include "model/ReinitInstanceResult.h"
+#include "model/ReinitInstancesRequest.h"
+#include "model/ReinitInstancesResult.h"
 #include "model/ReleaseARMServerInstanceRequest.h"
 #include "model/ReleaseARMServerInstanceResult.h"
 #include "model/ReleaseInstanceRequest.h"
@@ -394,12 +404,16 @@
 #include "model/StartEpnInstanceResult.h"
 #include "model/StartInstanceRequest.h"
 #include "model/StartInstanceResult.h"
+#include "model/StartInstancesRequest.h"
+#include "model/StartInstancesResult.h"
 #include "model/StartLoadBalancerListenerRequest.h"
 #include "model/StartLoadBalancerListenerResult.h"
 #include "model/StopEpnInstanceRequest.h"
 #include "model/StopEpnInstanceResult.h"
 #include "model/StopInstanceRequest.h"
 #include "model/StopInstanceResult.h"
+#include "model/StopInstancesRequest.h"
+#include "model/StopInstancesResult.h"
 #include "model/StopLoadBalancerListenerRequest.h"
 #include "model/StopLoadBalancerListenerResult.h"
 #include "model/UnAssociateEnsEipAddressRequest.h"
@@ -748,6 +762,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeMountTargetsResult> DescribeMountTargetsOutcome;
 			typedef std::future<DescribeMountTargetsOutcome> DescribeMountTargetsOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeMountTargetsRequest&, const DescribeMountTargetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMountTargetsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeNCInformationResult> DescribeNCInformationOutcome;
+			typedef std::future<DescribeNCInformationOutcome> DescribeNCInformationOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DescribeNCInformationRequest&, const DescribeNCInformationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNCInformationAsyncHandler;
 			typedef Outcome<Error, Model::DescribeNatGatewaysResult> DescribeNatGatewaysOutcome;
 			typedef std::future<DescribeNatGatewaysOutcome> DescribeNatGatewaysOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeNatGatewaysRequest&, const DescribeNatGatewaysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNatGatewaysAsyncHandler;
@@ -772,9 +789,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeRegionIspsResult> DescribeRegionIspsOutcome;
 			typedef std::future<DescribeRegionIspsOutcome> DescribeRegionIspsOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeRegionIspsRequest&, const DescribeRegionIspsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionIspsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionResourceResult> DescribeRegionResourceOutcome;
+			typedef std::future<DescribeRegionResourceOutcome> DescribeRegionResourceOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DescribeRegionResourceRequest&, const DescribeRegionResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionResourceAsyncHandler;
 			typedef Outcome<Error, Model::DescribeReservedResourceResult> DescribeReservedResourceOutcome;
 			typedef std::future<DescribeReservedResourceOutcome> DescribeReservedResourceOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeReservedResourceRequest&, const DescribeReservedResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeReservedResourceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeResourceTimelineResult> DescribeResourceTimelineOutcome;
+			typedef std::future<DescribeResourceTimelineOutcome> DescribeResourceTimelineOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::DescribeResourceTimelineRequest&, const DescribeResourceTimelineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeResourceTimelineAsyncHandler;
 			typedef Outcome<Error, Model::DescribeSecurityGroupAttributeResult> DescribeSecurityGroupAttributeOutcome;
 			typedef std::future<DescribeSecurityGroupAttributeOutcome> DescribeSecurityGroupAttributeOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::DescribeSecurityGroupAttributeRequest&, const DescribeSecurityGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityGroupAttributeAsyncHandler;
@@ -892,9 +915,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RebootInstanceResult> RebootInstanceOutcome;
 			typedef std::future<RebootInstanceOutcome> RebootInstanceOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::RebootInstanceRequest&, const RebootInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebootInstanceAsyncHandler;
+			typedef Outcome<Error, Model::RebootInstancesResult> RebootInstancesOutcome;
+			typedef std::future<RebootInstancesOutcome> RebootInstancesOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::RebootInstancesRequest&, const RebootInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebootInstancesAsyncHandler;
 			typedef Outcome<Error, Model::ReinitInstanceResult> ReinitInstanceOutcome;
 			typedef std::future<ReinitInstanceOutcome> ReinitInstanceOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::ReinitInstanceRequest&, const ReinitInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReinitInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ReinitInstancesResult> ReinitInstancesOutcome;
+			typedef std::future<ReinitInstancesOutcome> ReinitInstancesOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::ReinitInstancesRequest&, const ReinitInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReinitInstancesAsyncHandler;
 			typedef Outcome<Error, Model::ReleaseARMServerInstanceResult> ReleaseARMServerInstanceOutcome;
 			typedef std::future<ReleaseARMServerInstanceOutcome> ReleaseARMServerInstanceOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::ReleaseARMServerInstanceRequest&, const ReleaseARMServerInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseARMServerInstanceAsyncHandler;
@@ -979,6 +1008,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StartInstanceResult> StartInstanceOutcome;
 			typedef std::future<StartInstanceOutcome> StartInstanceOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::StartInstanceRequest&, const StartInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StartInstancesResult> StartInstancesOutcome;
+			typedef std::future<StartInstancesOutcome> StartInstancesOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::StartInstancesRequest&, const StartInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartInstancesAsyncHandler;
 			typedef Outcome<Error, Model::StartLoadBalancerListenerResult> StartLoadBalancerListenerOutcome;
 			typedef std::future<StartLoadBalancerListenerOutcome> StartLoadBalancerListenerOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::StartLoadBalancerListenerRequest&, const StartLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartLoadBalancerListenerAsyncHandler;
@@ -988,6 +1020,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StopInstanceResult> StopInstanceOutcome;
 			typedef std::future<StopInstanceOutcome> StopInstanceOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::StopInstanceRequest&, const StopInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StopInstancesResult> StopInstancesOutcome;
+			typedef std::future<StopInstancesOutcome> StopInstancesOutcomeCallable;
+			typedef std::function<void(const EnsClient*, const Model::StopInstancesRequest&, const StopInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInstancesAsyncHandler;
 			typedef Outcome<Error, Model::StopLoadBalancerListenerResult> StopLoadBalancerListenerOutcome;
 			typedef std::future<StopLoadBalancerListenerOutcome> StopLoadBalancerListenerOutcomeCallable;
 			typedef std::function<void(const EnsClient*, const Model::StopLoadBalancerListenerRequest&, const StopLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopLoadBalancerListenerAsyncHandler;
@@ -1338,6 +1373,9 @@ namespace AlibabaCloud
 			DescribeMountTargetsOutcome describeMountTargets(const Model::DescribeMountTargetsRequest &request)const;
 			void describeMountTargetsAsync(const Model::DescribeMountTargetsRequest& request, const DescribeMountTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeMountTargetsOutcomeCallable describeMountTargetsCallable(const Model::DescribeMountTargetsRequest& request) const;
+			DescribeNCInformationOutcome describeNCInformation(const Model::DescribeNCInformationRequest &request)const;
+			void describeNCInformationAsync(const Model::DescribeNCInformationRequest& request, const DescribeNCInformationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeNCInformationOutcomeCallable describeNCInformationCallable(const Model::DescribeNCInformationRequest& request) const;
 			DescribeNatGatewaysOutcome describeNatGateways(const Model::DescribeNatGatewaysRequest &request)const;
 			void describeNatGatewaysAsync(const Model::DescribeNatGatewaysRequest& request, const DescribeNatGatewaysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeNatGatewaysOutcomeCallable describeNatGatewaysCallable(const Model::DescribeNatGatewaysRequest& request) const;
@@ -1362,9 +1400,15 @@ namespace AlibabaCloud
 			DescribeRegionIspsOutcome describeRegionIsps(const Model::DescribeRegionIspsRequest &request)const;
 			void describeRegionIspsAsync(const Model::DescribeRegionIspsRequest& request, const DescribeRegionIspsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRegionIspsOutcomeCallable describeRegionIspsCallable(const Model::DescribeRegionIspsRequest& request) const;
+			DescribeRegionResourceOutcome describeRegionResource(const Model::DescribeRegionResourceRequest &request)const;
+			void describeRegionResourceAsync(const Model::DescribeRegionResourceRequest& request, const DescribeRegionResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionResourceOutcomeCallable describeRegionResourceCallable(const Model::DescribeRegionResourceRequest& request) const;
 			DescribeReservedResourceOutcome describeReservedResource(const Model::DescribeReservedResourceRequest &request)const;
 			void describeReservedResourceAsync(const Model::DescribeReservedResourceRequest& request, const DescribeReservedResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeReservedResourceOutcomeCallable describeReservedResourceCallable(const Model::DescribeReservedResourceRequest& request) const;
+			DescribeResourceTimelineOutcome describeResourceTimeline(const Model::DescribeResourceTimelineRequest &request)const;
+			void describeResourceTimelineAsync(const Model::DescribeResourceTimelineRequest& request, const DescribeResourceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeResourceTimelineOutcomeCallable describeResourceTimelineCallable(const Model::DescribeResourceTimelineRequest& request) const;
 			DescribeSecurityGroupAttributeOutcome describeSecurityGroupAttribute(const Model::DescribeSecurityGroupAttributeRequest &request)const;
 			void describeSecurityGroupAttributeAsync(const Model::DescribeSecurityGroupAttributeRequest& request, const DescribeSecurityGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSecurityGroupAttributeOutcomeCallable describeSecurityGroupAttributeCallable(const Model::DescribeSecurityGroupAttributeRequest& request) const;
@@ -1482,9 +1526,15 @@ namespace AlibabaCloud
 			RebootInstanceOutcome rebootInstance(const Model::RebootInstanceRequest &request)const;
 			void rebootInstanceAsync(const Model::RebootInstanceRequest& request, const RebootInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RebootInstanceOutcomeCallable rebootInstanceCallable(const Model::RebootInstanceRequest& request) const;
+			RebootInstancesOutcome rebootInstances(const Model::RebootInstancesRequest &request)const;
+			void rebootInstancesAsync(const Model::RebootInstancesRequest& request, const RebootInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RebootInstancesOutcomeCallable rebootInstancesCallable(const Model::RebootInstancesRequest& request) const;
 			ReinitInstanceOutcome reinitInstance(const Model::ReinitInstanceRequest &request)const;
 			void reinitInstanceAsync(const Model::ReinitInstanceRequest& request, const ReinitInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ReinitInstanceOutcomeCallable reinitInstanceCallable(const Model::ReinitInstanceRequest& request) const;
+			ReinitInstancesOutcome reinitInstances(const Model::ReinitInstancesRequest &request)const;
+			void reinitInstancesAsync(const Model::ReinitInstancesRequest& request, const ReinitInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReinitInstancesOutcomeCallable reinitInstancesCallable(const Model::ReinitInstancesRequest& request) const;
 			ReleaseARMServerInstanceOutcome releaseARMServerInstance(const Model::ReleaseARMServerInstanceRequest &request)const;
 			void releaseARMServerInstanceAsync(const Model::ReleaseARMServerInstanceRequest& request, const ReleaseARMServerInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ReleaseARMServerInstanceOutcomeCallable releaseARMServerInstanceCallable(const Model::ReleaseARMServerInstanceRequest& request) const;
@@ -1569,6 +1619,9 @@ namespace AlibabaCloud
 			StartInstanceOutcome startInstance(const Model::StartInstanceRequest &request)const;
 			void startInstanceAsync(const Model::StartInstanceRequest& request, const StartInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartInstanceOutcomeCallable startInstanceCallable(const Model::StartInstanceRequest& request) const;
+			StartInstancesOutcome startInstances(const Model::StartInstancesRequest &request)const;
+			void startInstancesAsync(const Model::StartInstancesRequest& request, const StartInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartInstancesOutcomeCallable startInstancesCallable(const Model::StartInstancesRequest& request) const;
 			StartLoadBalancerListenerOutcome startLoadBalancerListener(const Model::StartLoadBalancerListenerRequest &request)const;
 			void startLoadBalancerListenerAsync(const Model::StartLoadBalancerListenerRequest& request, const StartLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartLoadBalancerListenerOutcomeCallable startLoadBalancerListenerCallable(const Model::StartLoadBalancerListenerRequest& request) const;
@@ -1578,6 +1631,9 @@ namespace AlibabaCloud
 			StopInstanceOutcome stopInstance(const Model::StopInstanceRequest &request)const;
 			void stopInstanceAsync(const Model::StopInstanceRequest& request, const StopInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopInstanceOutcomeCallable stopInstanceCallable(const Model::StopInstanceRequest& request) const;
+			StopInstancesOutcome stopInstances(const Model::StopInstancesRequest &request)const;
+			void stopInstancesAsync(const Model::StopInstancesRequest& request, const StopInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopInstancesOutcomeCallable stopInstancesCallable(const Model::StopInstancesRequest& request) const;
 			StopLoadBalancerListenerOutcome stopLoadBalancerListener(const Model::StopLoadBalancerListenerRequest &request)const;
 			void stopLoadBalancerListenerAsync(const Model::StopLoadBalancerListenerRequest& request, const StopLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopLoadBalancerListenerOutcomeCallable stopLoadBalancerListenerCallable(const Model::StopLoadBalancerListenerRequest& request) const;

ens/include/alibabacloud/ens/model/DescribeNCInformationRequest.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_ENS_MODEL_DESCRIBENCINFORMATIONREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBENCINFORMATIONREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DescribeNCInformationRequest : public RpcServiceRequest {
+public:
+	DescribeNCInformationRequest();
+	~DescribeNCInformationRequest();
+	std::string getEnsRegionId() const;
+	void setEnsRegionId(const std::string &ensRegionId);
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	std::string getOpenapiCheck() const;
+	void setOpenapiCheck(const std::string &openapiCheck);
+
+private:
+	std::string ensRegionId_;
+	std::string resourceId_;
+	std::string openapiCheck_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBENCINFORMATIONREQUEST_H_

ens/include/alibabacloud/ens/model/DescribeNCInformationResult.h

@@ -0,0 +1,177 @@
+/*
+ * 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_ENS_MODEL_DESCRIBENCINFORMATIONRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBENCINFORMATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DescribeNCInformationResult : public ServiceResult
+			{
+			public:
+				struct Pager
+				{
+					long size;
+					long total;
+					long page;
+				};
+				struct DataItem
+				{
+					struct Cpu
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Memory
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Gpu
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Hdd
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Ssd
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Nvme
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Info
+					{
+						std::string uuid;
+						std::string ip;
+						std::vector<std::string> tag;
+						std::string name;
+					};
+					Ssd ssd;
+					Nvme nvme;
+					Memory memory;
+					Cpu cpu;
+					Hdd hdd;
+					std::string region;
+					Info info;
+					bool online;
+					Gpu gpu;
+					std::string _virtual;
+				};
+
+
+				DescribeNCInformationResult();
+				explicit DescribeNCInformationResult(const std::string &payload);
+				~DescribeNCInformationResult();
+				std::string getMsg()const;
+				std::string getDesc()const;
+				int getTotalCount()const;
+				int getCurrentPage()const;
+				Pager getPager()const;
+				std::vector<DataItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string msg_;
+				std::string desc_;
+				int totalCount_;
+				int currentPage_;
+				Pager pager_;
+				std::vector<DataItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBENCINFORMATIONRESULT_H_

ens/include/alibabacloud/ens/model/DescribeRegionResourceRequest.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_ENS_MODEL_DESCRIBEREGIONRESOURCEREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBEREGIONRESOURCEREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DescribeRegionResourceRequest : public RpcServiceRequest {
+public:
+	DescribeRegionResourceRequest();
+	~DescribeRegionResourceRequest();
+	std::string getIspType() const;
+	void setIspType(const std::string &ispType);
+	std::string getEnsRegionId() const;
+	void setEnsRegionId(const std::string &ensRegionId);
+	std::string getOpenapiCheck() const;
+	void setOpenapiCheck(const std::string &openapiCheck);
+
+private:
+	std::string ispType_;
+	std::string ensRegionId_;
+	std::string openapiCheck_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEREGIONRESOURCEREQUEST_H_

ens/include/alibabacloud/ens/model/DescribeRegionResourceResult.h

@@ -0,0 +1,310 @@
+/*
+ * 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_ENS_MODEL_DESCRIBEREGIONRESOURCERESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBEREGIONRESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DescribeRegionResourceResult : public ServiceResult
+			{
+			public:
+				struct Pager
+				{
+					long size;
+					long total;
+					long page;
+				};
+				struct DataItem
+				{
+					struct ArmCard
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Bandwidth
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct BlockStorage
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Cpu
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Memory
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Gpu
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Hdd
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Ssd
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Nvme
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct OssStorage
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Pangu
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct PcfarmNum
+					{
+						long reserveDisableTotal;
+						std::string type;
+						long remain;
+						long used;
+						long usedRatio;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						bool display;
+						long reserved;
+					};
+					struct Ipv4sItem
+					{
+						long remain;
+						long usedRatio;
+						std::string isp;
+						std::string vlan;
+						long reserveDisableTotal;
+						std::string type;
+						long used;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						std::string display;
+						long reserved;
+					};
+					struct Ipv6sItem
+					{
+						long remain;
+						long usedRatio;
+						std::string isp;
+						std::string vlan;
+						long reserveDisableTotal;
+						std::string type;
+						long used;
+						long oversellRatio;
+						long statusDisableTotal;
+						long total;
+						bool statusDisable;
+						bool reserveDisable;
+						std::string display;
+						long reserved;
+					};
+					std::string countryName;
+					Memory memory;
+					std::vector<std::string> attributes;
+					Cpu cpu;
+					Hdd hdd;
+					PcfarmNum pcfarmNum;
+					Gpu gpu;
+					std::string name;
+					std::string areaName;
+					std::string provinceName;
+					BlockStorage blockStorage;
+					Bandwidth bandwidth;
+					bool statusDisable;
+					std::string countryCode;
+					bool reserveDisable;
+					Ssd ssd;
+					Nvme nvme;
+					bool poc;
+					std::string houseId;
+					std::vector<std::string> ispTypes;
+					ArmCard armCard;
+					std::string type;
+					std::string uuid;
+					std::vector<DataItem::Ipv6sItem> ipv6s;
+					std::vector<DataItem::Ipv4sItem> ipv4s;
+					std::string areaCode;
+					OssStorage ossStorage;
+					std::string provinceCode;
+					std::string _virtual;
+					Pangu pangu;
+				};
+
+
+				DescribeRegionResourceResult();
+				explicit DescribeRegionResourceResult(const std::string &payload);
+				~DescribeRegionResourceResult();
+				std::string getMsg()const;
+				std::string getDesc()const;
+				Pager getPager()const;
+				std::vector<DataItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string msg_;
+				std::string desc_;
+				Pager pager_;
+				std::vector<DataItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEREGIONRESOURCERESULT_H_

ens/include/alibabacloud/ens/model/DescribeResourceTimelineRequest.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_ENS_MODEL_DESCRIBERESOURCETIMELINEREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBERESOURCETIMELINEREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT DescribeResourceTimelineRequest : public RpcServiceRequest {
+public:
+	DescribeResourceTimelineRequest();
+	~DescribeResourceTimelineRequest();
+	std::string getUuid() const;
+	void setUuid(const std::string &uuid);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getBeginTime() const;
+	void setBeginTime(const std::string &beginTime);
+	std::string getOpenapiCheck() const;
+	void setOpenapiCheck(const std::string &openapiCheck);
+
+private:
+	std::string uuid_;
+	std::string endTime_;
+	std::string beginTime_;
+	std::string openapiCheck_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBERESOURCETIMELINEREQUEST_H_

ens/include/alibabacloud/ens/model/DescribeResourceTimelineResult.h

@@ -0,0 +1,89 @@
+/*
+ * 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_ENS_MODEL_DESCRIBERESOURCETIMELINERESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_DESCRIBERESOURCETIMELINERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT DescribeResourceTimelineResult : public ServiceResult
+			{
+			public:
+				struct 可用性事件
+				{
+					std::string occurrenceTime;
+					std::string type;
+					std::string reason;
+					std::string name;
+				};
+				struct 建设状态事件
+				{
+					std::string occurrenceTime;
+					std::string type;
+					std::string reason;
+					std::string name;
+				};
+				struct 资源扣减事件
+				{
+					std::string occurrenceTime;
+					std::string type;
+					std::string reason;
+					std::string name;
+				};
+				struct 资源预留事件
+				{
+					std::string occurrenceTime;
+					std::string type;
+					std::string reason;
+					std::string name;
+				};
+
+
+				DescribeResourceTimelineResult();
+				explicit DescribeResourceTimelineResult(const std::string &payload);
+				~DescribeResourceTimelineResult();
+				std::string getMsg()const;
+				std::string getDesc()const;
+				std::vector<资源扣减事件> getInventoryEvents()const;
+				std::vector<可用性事件> getAvailableEvents()const;
+				std::vector<建设状态事件> getBizEvents()const;
+				std::vector<资源预留事件> getReserveEvents()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string msg_;
+				std::string desc_;
+				std::vector<资源扣减事件> inventoryEvents_;
+				std::vector<可用性事件> availableEvents_;
+				std::vector<建设状态事件> bizEvents_;
+				std::vector<资源预留事件> reserveEvents_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBERESOURCETIMELINERESULT_H_

ens/include/alibabacloud/ens/model/ModifyInstanceAttributeRequest.h

@@ -30,15 +30,21 @@ class ALIBABACLOUD_ENS_EXPORT ModifyInstanceAttributeRequest : public RpcService
 public:
 	ModifyInstanceAttributeRequest();
 	~ModifyInstanceAttributeRequest();
+	std::string getUserData() const;
+	void setUserData(const std::string &userData);
 	std::string getPassword() const;
 	void setPassword(const std::string &password);
+	std::string getHostName() const;
+	void setHostName(const std::string &hostName);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getInstanceName() const;
 	void setInstanceName(const std::string &instanceName);
 
 private:
+	std::string userData_;
 	std::string password_;
+	std::string hostName_;
 	std::string instanceId_;
 	std::string instanceName_;
 };

ens/include/alibabacloud/ens/model/RebootInstancesRequest.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_ENS_MODEL_REBOOTINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_REBOOTINSTANCESREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT RebootInstancesRequest : public RpcServiceRequest {
+public:
+	RebootInstancesRequest();
+	~RebootInstancesRequest();
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+
+private:
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_REBOOTINSTANCESREQUEST_H_

ens/include/alibabacloud/ens/model/RebootInstancesResult.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_ENS_MODEL_REBOOTINSTANCESRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_REBOOTINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT RebootInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstanceResponsesItem
+				{
+					std::string message;
+					std::string instanceId;
+					long code;
+				};
+
+
+				RebootInstancesResult();
+				explicit RebootInstancesResult(const std::string &payload);
+				~RebootInstancesResult();
+				std::vector<InstanceResponsesItem> getInstanceResponses()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceResponsesItem> instanceResponses_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_REBOOTINSTANCESRESULT_H_

ens/include/alibabacloud/ens/model/ReinitInstancesRequest.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_ENS_MODEL_REINITINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_REINITINSTANCESREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT ReinitInstancesRequest : public RpcServiceRequest {
+public:
+	ReinitInstancesRequest();
+	~ReinitInstancesRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getPassword() const;
+	void setPassword(const std::string &password);
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+
+private:
+	std::string imageId_;
+	std::string password_;
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_REINITINSTANCESREQUEST_H_

ens/include/alibabacloud/ens/model/ReinitInstancesResult.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_ENS_MODEL_REINITINSTANCESRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_REINITINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT ReinitInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstanceResponsesItem
+				{
+					std::string message;
+					std::string instanceId;
+					long code;
+				};
+
+
+				ReinitInstancesResult();
+				explicit ReinitInstancesResult(const std::string &payload);
+				~ReinitInstancesResult();
+				std::vector<InstanceResponsesItem> getInstanceResponses()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceResponsesItem> instanceResponses_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_REINITINSTANCESRESULT_H_

ens/include/alibabacloud/ens/model/StartInstancesRequest.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_ENS_MODEL_STARTINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_STARTINSTANCESREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT StartInstancesRequest : public RpcServiceRequest {
+public:
+	StartInstancesRequest();
+	~StartInstancesRequest();
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+
+private:
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_STARTINSTANCESREQUEST_H_

ens/include/alibabacloud/ens/model/StartInstancesResult.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_ENS_MODEL_STARTINSTANCESRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_STARTINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT StartInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstanceResponsesItem
+				{
+					std::string message;
+					std::string instanceId;
+					long code;
+				};
+
+
+				StartInstancesResult();
+				explicit StartInstancesResult(const std::string &payload);
+				~StartInstancesResult();
+				std::vector<InstanceResponsesItem> getInstanceResponses()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceResponsesItem> instanceResponses_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_STARTINSTANCESRESULT_H_

ens/include/alibabacloud/ens/model/StopInstancesRequest.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_ENS_MODEL_STOPINSTANCESREQUEST_H_
+#define ALIBABACLOUD_ENS_MODEL_STOPINSTANCESREQUEST_H_
+
+#include <alibabacloud/ens/EnsExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ens {
+namespace Model {
+class ALIBABACLOUD_ENS_EXPORT StopInstancesRequest : public RpcServiceRequest {
+public:
+	StopInstancesRequest();
+	~StopInstancesRequest();
+	std::vector<std::string> getInstanceIds() const;
+	void setInstanceIds(const std::vector<std::string> &instanceIds);
+
+private:
+	std::vector<std::string> instanceIds_;
+};
+} // namespace Model
+} // namespace Ens
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ENS_MODEL_STOPINSTANCESREQUEST_H_

ens/include/alibabacloud/ens/model/StopInstancesResult.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_ENS_MODEL_STOPINSTANCESRESULT_H_
+#define ALIBABACLOUD_ENS_MODEL_STOPINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ens/EnsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ens
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ENS_EXPORT StopInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstanceResponsesItem
+				{
+					std::string message;
+					std::string instanceId;
+					long code;
+				};
+
+
+				StopInstancesResult();
+				explicit StopInstancesResult(const std::string &payload);
+				~StopInstancesResult();
+				std::vector<InstanceResponsesItem> getInstanceResponses()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceResponsesItem> instanceResponses_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ENS_MODEL_STOPINSTANCESRESULT_H_

ens/src/EnsClient.cc

@@ -3975,6 +3975,42 @@ EnsClient::DescribeMountTargetsOutcomeCallable EnsClient::describeMountTargetsCa
 	return task->get_future();
 }
 
+EnsClient::DescribeNCInformationOutcome EnsClient::describeNCInformation(const DescribeNCInformationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeNCInformationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeNCInformationOutcome(DescribeNCInformationResult(outcome.result()));
+	else
+		return DescribeNCInformationOutcome(outcome.error());
+}
+
+void EnsClient::describeNCInformationAsync(const DescribeNCInformationRequest& request, const DescribeNCInformationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeNCInformation(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DescribeNCInformationOutcomeCallable EnsClient::describeNCInformationCallable(const DescribeNCInformationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeNCInformationOutcome()>>(
+			[this, request]()
+			{
+			return this->describeNCInformation(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::DescribeNatGatewaysOutcome EnsClient::describeNatGateways(const DescribeNatGatewaysRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4263,6 +4299,42 @@ EnsClient::DescribeRegionIspsOutcomeCallable EnsClient::describeRegionIspsCallab
 	return task->get_future();
 }
 
+EnsClient::DescribeRegionResourceOutcome EnsClient::describeRegionResource(const DescribeRegionResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionResourceOutcome(DescribeRegionResourceResult(outcome.result()));
+	else
+		return DescribeRegionResourceOutcome(outcome.error());
+}
+
+void EnsClient::describeRegionResourceAsync(const DescribeRegionResourceRequest& request, const DescribeRegionResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegionResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DescribeRegionResourceOutcomeCallable EnsClient::describeRegionResourceCallable(const DescribeRegionResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegionResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::DescribeReservedResourceOutcome EnsClient::describeReservedResource(const DescribeReservedResourceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4299,6 +4371,42 @@ EnsClient::DescribeReservedResourceOutcomeCallable EnsClient::describeReservedRe
 	return task->get_future();
 }
 
+EnsClient::DescribeResourceTimelineOutcome EnsClient::describeResourceTimeline(const DescribeResourceTimelineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeResourceTimelineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeResourceTimelineOutcome(DescribeResourceTimelineResult(outcome.result()));
+	else
+		return DescribeResourceTimelineOutcome(outcome.error());
+}
+
+void EnsClient::describeResourceTimelineAsync(const DescribeResourceTimelineRequest& request, const DescribeResourceTimelineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeResourceTimeline(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::DescribeResourceTimelineOutcomeCallable EnsClient::describeResourceTimelineCallable(const DescribeResourceTimelineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeResourceTimelineOutcome()>>(
+			[this, request]()
+			{
+			return this->describeResourceTimeline(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::DescribeSecurityGroupAttributeOutcome EnsClient::describeSecurityGroupAttribute(const DescribeSecurityGroupAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5703,6 +5811,42 @@ EnsClient::RebootInstanceOutcomeCallable EnsClient::rebootInstanceCallable(const
 	return task->get_future();
 }
 
+EnsClient::RebootInstancesOutcome EnsClient::rebootInstances(const RebootInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RebootInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RebootInstancesOutcome(RebootInstancesResult(outcome.result()));
+	else
+		return RebootInstancesOutcome(outcome.error());
+}
+
+void EnsClient::rebootInstancesAsync(const RebootInstancesRequest& request, const RebootInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rebootInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::RebootInstancesOutcomeCallable EnsClient::rebootInstancesCallable(const RebootInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RebootInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->rebootInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::ReinitInstanceOutcome EnsClient::reinitInstance(const ReinitInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5739,6 +5883,42 @@ EnsClient::ReinitInstanceOutcomeCallable EnsClient::reinitInstanceCallable(const
 	return task->get_future();
 }
 
+EnsClient::ReinitInstancesOutcome EnsClient::reinitInstances(const ReinitInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReinitInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReinitInstancesOutcome(ReinitInstancesResult(outcome.result()));
+	else
+		return ReinitInstancesOutcome(outcome.error());
+}
+
+void EnsClient::reinitInstancesAsync(const ReinitInstancesRequest& request, const ReinitInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, reinitInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::ReinitInstancesOutcomeCallable EnsClient::reinitInstancesCallable(const ReinitInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReinitInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->reinitInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::ReleaseARMServerInstanceOutcome EnsClient::releaseARMServerInstance(const ReleaseARMServerInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6747,6 +6927,42 @@ EnsClient::StartInstanceOutcomeCallable EnsClient::startInstanceCallable(const S
 	return task->get_future();
 }
 
+EnsClient::StartInstancesOutcome EnsClient::startInstances(const StartInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartInstancesOutcome(StartInstancesResult(outcome.result()));
+	else
+		return StartInstancesOutcome(outcome.error());
+}
+
+void EnsClient::startInstancesAsync(const StartInstancesRequest& request, const StartInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::StartInstancesOutcomeCallable EnsClient::startInstancesCallable(const StartInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->startInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::StartLoadBalancerListenerOutcome EnsClient::startLoadBalancerListener(const StartLoadBalancerListenerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6855,6 +7071,42 @@ EnsClient::StopInstanceOutcomeCallable EnsClient::stopInstanceCallable(const Sto
 	return task->get_future();
 }
 
+EnsClient::StopInstancesOutcome EnsClient::stopInstances(const StopInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopInstancesOutcome(StopInstancesResult(outcome.result()));
+	else
+		return StopInstancesOutcome(outcome.error());
+}
+
+void EnsClient::stopInstancesAsync(const StopInstancesRequest& request, const StopInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EnsClient::StopInstancesOutcomeCallable EnsClient::stopInstancesCallable(const StopInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->stopInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 EnsClient::StopLoadBalancerListenerOutcome EnsClient::stopLoadBalancerListener(const StopLoadBalancerListenerRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ens/src/model/DescribeNCInformationRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeNCInformationRequest.h>
+
+using AlibabaCloud::Ens::Model::DescribeNCInformationRequest;
+
+DescribeNCInformationRequest::DescribeNCInformationRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DescribeNCInformation") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeNCInformationRequest::~DescribeNCInformationRequest() {}
+
+std::string DescribeNCInformationRequest::getEnsRegionId() const {
+  return ensRegionId_;
+}
+
+void DescribeNCInformationRequest::setEnsRegionId(const std::string &ensRegionId) {
+  ensRegionId_ = ensRegionId;
+  setParameter(std::string("EnsRegionId"), ensRegionId);
+}
+
+std::string DescribeNCInformationRequest::getResourceId() const {
+  return resourceId_;
+}
+
+void DescribeNCInformationRequest::setResourceId(const std::string &resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), resourceId);
+}
+
+std::string DescribeNCInformationRequest::getOpenapiCheck() const {
+  return openapiCheck_;
+}
+
+void DescribeNCInformationRequest::setOpenapiCheck(const std::string &openapiCheck) {
+  openapiCheck_ = openapiCheck;
+  setParameter(std::string("OpenapiCheck"), openapiCheck);
+}
+

ens/src/model/DescribeNCInformationResult.cc

@@ -0,0 +1,261 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeNCInformationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+DescribeNCInformationResult::DescribeNCInformationResult() :
+	ServiceResult()
+{}
+
+DescribeNCInformationResult::DescribeNCInformationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeNCInformationResult::~DescribeNCInformationResult()
+{}
+
+void DescribeNCInformationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["dataItem"];
+	for (auto valueDatadataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDatadataItem["Online"].isNull())
+			dataObject.online = valueDatadataItem["Online"].asString() == "true";
+		if(!valueDatadataItem["Region"].isNull())
+			dataObject.region = valueDatadataItem["Region"].asString();
+		if(!valueDatadataItem["Virtual"].isNull())
+			dataObject._virtual = valueDatadataItem["Virtual"].asString();
+		auto cpuNode = value["Cpu"];
+		if(!cpuNode["Display"].isNull())
+			dataObject.cpu.display = cpuNode["Display"].asString() == "true";
+		if(!cpuNode["OversellRatio"].isNull())
+			dataObject.cpu.oversellRatio = std::stol(cpuNode["OversellRatio"].asString());
+		if(!cpuNode["Remain"].isNull())
+			dataObject.cpu.remain = std::stol(cpuNode["Remain"].asString());
+		if(!cpuNode["Reserved"].isNull())
+			dataObject.cpu.reserved = std::stol(cpuNode["Reserved"].asString());
+		if(!cpuNode["ReserveDisable"].isNull())
+			dataObject.cpu.reserveDisable = cpuNode["ReserveDisable"].asString() == "true";
+		if(!cpuNode["ReserveDisableTotal"].isNull())
+			dataObject.cpu.reserveDisableTotal = std::stol(cpuNode["ReserveDisableTotal"].asString());
+		if(!cpuNode["StatusDisable"].isNull())
+			dataObject.cpu.statusDisable = cpuNode["StatusDisable"].asString() == "true";
+		if(!cpuNode["StatusDisableTotal"].isNull())
+			dataObject.cpu.statusDisableTotal = std::stol(cpuNode["StatusDisableTotal"].asString());
+		if(!cpuNode["Total"].isNull())
+			dataObject.cpu.total = std::stol(cpuNode["Total"].asString());
+		if(!cpuNode["Type"].isNull())
+			dataObject.cpu.type = cpuNode["Type"].asString();
+		if(!cpuNode["Used"].isNull())
+			dataObject.cpu.used = std::stol(cpuNode["Used"].asString());
+		if(!cpuNode["UsedRatio"].isNull())
+			dataObject.cpu.usedRatio = std::stol(cpuNode["UsedRatio"].asString());
+		auto memoryNode = value["Memory"];
+		if(!memoryNode["Display"].isNull())
+			dataObject.memory.display = memoryNode["Display"].asString() == "true";
+		if(!memoryNode["OversellRatio"].isNull())
+			dataObject.memory.oversellRatio = std::stol(memoryNode["OversellRatio"].asString());
+		if(!memoryNode["Remain"].isNull())
+			dataObject.memory.remain = std::stol(memoryNode["Remain"].asString());
+		if(!memoryNode["Reserved"].isNull())
+			dataObject.memory.reserved = std::stol(memoryNode["Reserved"].asString());
+		if(!memoryNode["ReserveDisable"].isNull())
+			dataObject.memory.reserveDisable = memoryNode["ReserveDisable"].asString() == "true";
+		if(!memoryNode["ReserveDisableTotal"].isNull())
+			dataObject.memory.reserveDisableTotal = std::stol(memoryNode["ReserveDisableTotal"].asString());
+		if(!memoryNode["StatusDisable"].isNull())
+			dataObject.memory.statusDisable = memoryNode["StatusDisable"].asString() == "true";
+		if(!memoryNode["StatusDisableTotal"].isNull())
+			dataObject.memory.statusDisableTotal = std::stol(memoryNode["StatusDisableTotal"].asString());
+		if(!memoryNode["Total"].isNull())
+			dataObject.memory.total = std::stol(memoryNode["Total"].asString());
+		if(!memoryNode["Type"].isNull())
+			dataObject.memory.type = memoryNode["Type"].asString();
+		if(!memoryNode["Used"].isNull())
+			dataObject.memory.used = std::stol(memoryNode["Used"].asString());
+		if(!memoryNode["UsedRatio"].isNull())
+			dataObject.memory.usedRatio = std::stol(memoryNode["UsedRatio"].asString());
+		auto gpuNode = value["Gpu"];
+		if(!gpuNode["Display"].isNull())
+			dataObject.gpu.display = gpuNode["Display"].asString() == "true";
+		if(!gpuNode["OversellRatio"].isNull())
+			dataObject.gpu.oversellRatio = std::stol(gpuNode["OversellRatio"].asString());
+		if(!gpuNode["Remain"].isNull())
+			dataObject.gpu.remain = std::stol(gpuNode["Remain"].asString());
+		if(!gpuNode["Reserved"].isNull())
+			dataObject.gpu.reserved = std::stol(gpuNode["Reserved"].asString());
+		if(!gpuNode["ReserveDisable"].isNull())
+			dataObject.gpu.reserveDisable = gpuNode["ReserveDisable"].asString() == "true";
+		if(!gpuNode["ReserveDisableTotal"].isNull())
+			dataObject.gpu.reserveDisableTotal = std::stol(gpuNode["ReserveDisableTotal"].asString());
+		if(!gpuNode["StatusDisable"].isNull())
+			dataObject.gpu.statusDisable = gpuNode["StatusDisable"].asString() == "true";
+		if(!gpuNode["StatusDisableTotal"].isNull())
+			dataObject.gpu.statusDisableTotal = std::stol(gpuNode["StatusDisableTotal"].asString());
+		if(!gpuNode["Total"].isNull())
+			dataObject.gpu.total = std::stol(gpuNode["Total"].asString());
+		if(!gpuNode["Type"].isNull())
+			dataObject.gpu.type = gpuNode["Type"].asString();
+		if(!gpuNode["Used"].isNull())
+			dataObject.gpu.used = std::stol(gpuNode["Used"].asString());
+		if(!gpuNode["UsedRatio"].isNull())
+			dataObject.gpu.usedRatio = std::stol(gpuNode["UsedRatio"].asString());
+		auto hddNode = value["Hdd"];
+		if(!hddNode["Display"].isNull())
+			dataObject.hdd.display = hddNode["Display"].asString() == "true";
+		if(!hddNode["OversellRatio"].isNull())
+			dataObject.hdd.oversellRatio = std::stol(hddNode["OversellRatio"].asString());
+		if(!hddNode["Remain"].isNull())
+			dataObject.hdd.remain = std::stol(hddNode["Remain"].asString());
+		if(!hddNode["Reserved"].isNull())
+			dataObject.hdd.reserved = std::stol(hddNode["Reserved"].asString());
+		if(!hddNode["ReserveDisable"].isNull())
+			dataObject.hdd.reserveDisable = hddNode["ReserveDisable"].asString() == "true";
+		if(!hddNode["ReserveDisableTotal"].isNull())
+			dataObject.hdd.reserveDisableTotal = std::stol(hddNode["ReserveDisableTotal"].asString());
+		if(!hddNode["StatusDisable"].isNull())
+			dataObject.hdd.statusDisable = hddNode["StatusDisable"].asString() == "true";
+		if(!hddNode["StatusDisableTotal"].isNull())
+			dataObject.hdd.statusDisableTotal = std::stol(hddNode["StatusDisableTotal"].asString());
+		if(!hddNode["Total"].isNull())
+			dataObject.hdd.total = std::stol(hddNode["Total"].asString());
+		if(!hddNode["Type"].isNull())
+			dataObject.hdd.type = hddNode["Type"].asString();
+		if(!hddNode["Used"].isNull())
+			dataObject.hdd.used = std::stol(hddNode["Used"].asString());
+		if(!hddNode["UsedRatio"].isNull())
+			dataObject.hdd.usedRatio = std::stol(hddNode["UsedRatio"].asString());
+		auto ssdNode = value["Ssd"];
+		if(!ssdNode["Display"].isNull())
+			dataObject.ssd.display = ssdNode["Display"].asString() == "true";
+		if(!ssdNode["OversellRatio"].isNull())
+			dataObject.ssd.oversellRatio = std::stol(ssdNode["OversellRatio"].asString());
+		if(!ssdNode["Remain"].isNull())
+			dataObject.ssd.remain = std::stol(ssdNode["Remain"].asString());
+		if(!ssdNode["Reserved"].isNull())
+			dataObject.ssd.reserved = std::stol(ssdNode["Reserved"].asString());
+		if(!ssdNode["ReserveDisable"].isNull())
+			dataObject.ssd.reserveDisable = ssdNode["ReserveDisable"].asString() == "true";
+		if(!ssdNode["ReserveDisableTotal"].isNull())
+			dataObject.ssd.reserveDisableTotal = std::stol(ssdNode["ReserveDisableTotal"].asString());
+		if(!ssdNode["StatusDisable"].isNull())
+			dataObject.ssd.statusDisable = ssdNode["StatusDisable"].asString() == "true";
+		if(!ssdNode["StatusDisableTotal"].isNull())
+			dataObject.ssd.statusDisableTotal = std::stol(ssdNode["StatusDisableTotal"].asString());
+		if(!ssdNode["Total"].isNull())
+			dataObject.ssd.total = std::stol(ssdNode["Total"].asString());
+		if(!ssdNode["Type"].isNull())
+			dataObject.ssd.type = ssdNode["Type"].asString();
+		if(!ssdNode["Used"].isNull())
+			dataObject.ssd.used = std::stol(ssdNode["Used"].asString());
+		if(!ssdNode["UsedRatio"].isNull())
+			dataObject.ssd.usedRatio = std::stol(ssdNode["UsedRatio"].asString());
+		auto nvmeNode = value["Nvme"];
+		if(!nvmeNode["Display"].isNull())
+			dataObject.nvme.display = nvmeNode["Display"].asString() == "true";
+		if(!nvmeNode["OversellRatio"].isNull())
+			dataObject.nvme.oversellRatio = std::stol(nvmeNode["OversellRatio"].asString());
+		if(!nvmeNode["Remain"].isNull())
+			dataObject.nvme.remain = std::stol(nvmeNode["Remain"].asString());
+		if(!nvmeNode["Reserved"].isNull())
+			dataObject.nvme.reserved = std::stol(nvmeNode["Reserved"].asString());
+		if(!nvmeNode["ReserveDisable"].isNull())
+			dataObject.nvme.reserveDisable = nvmeNode["ReserveDisable"].asString() == "true";
+		if(!nvmeNode["ReserveDisableTotal"].isNull())
+			dataObject.nvme.reserveDisableTotal = std::stol(nvmeNode["ReserveDisableTotal"].asString());
+		if(!nvmeNode["StatusDisable"].isNull())
+			dataObject.nvme.statusDisable = nvmeNode["StatusDisable"].asString() == "true";
+		if(!nvmeNode["StatusDisableTotal"].isNull())
+			dataObject.nvme.statusDisableTotal = std::stol(nvmeNode["StatusDisableTotal"].asString());
+		if(!nvmeNode["Total"].isNull())
+			dataObject.nvme.total = std::stol(nvmeNode["Total"].asString());
+		if(!nvmeNode["Type"].isNull())
+			dataObject.nvme.type = nvmeNode["Type"].asString();
+		if(!nvmeNode["Used"].isNull())
+			dataObject.nvme.used = std::stol(nvmeNode["Used"].asString());
+		if(!nvmeNode["UsedRatio"].isNull())
+			dataObject.nvme.usedRatio = std::stol(nvmeNode["UsedRatio"].asString());
+		auto infoNode = value["Info"];
+		if(!infoNode["Ip"].isNull())
+			dataObject.info.ip = infoNode["Ip"].asString();
+		if(!infoNode["Name"].isNull())
+			dataObject.info.name = infoNode["Name"].asString();
+		if(!infoNode["Uuid"].isNull())
+			dataObject.info.uuid = infoNode["Uuid"].asString();
+			auto allTag = infoNode["Tag"]["tags"];
+			for (auto value : allTag)
+				dataObject.info.tag.push_back(value.asString());
+		data_.push_back(dataObject);
+	}
+	auto pagerNode = value["Pager"];
+	if(!pagerNode["Page"].isNull())
+		pager_.page = std::stol(pagerNode["Page"].asString());
+	if(!pagerNode["Size"].isNull())
+		pager_.size = std::stol(pagerNode["Size"].asString());
+	if(!pagerNode["Total"].isNull())
+		pager_.total = std::stol(pagerNode["Total"].asString());
+	if(!value["CurrentPage"].isNull())
+		currentPage_ = std::stoi(value["CurrentPage"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["Msg"].isNull())
+		msg_ = value["Msg"].asString();
+	if(!value["Desc"].isNull())
+		desc_ = value["Desc"].asString();
+
+}
+
+std::string DescribeNCInformationResult::getMsg()const
+{
+	return msg_;
+}
+
+std::string DescribeNCInformationResult::getDesc()const
+{
+	return desc_;
+}
+
+int DescribeNCInformationResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeNCInformationResult::getCurrentPage()const
+{
+	return currentPage_;
+}
+
+DescribeNCInformationResult::Pager DescribeNCInformationResult::getPager()const
+{
+	return pager_;
+}
+
+std::vector<DescribeNCInformationResult::DataItem> DescribeNCInformationResult::getData()const
+{
+	return data_;
+}
+

ens/src/model/DescribeRegionResourceRequest.cc

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeRegionResourceRequest.h>
+
+using AlibabaCloud::Ens::Model::DescribeRegionResourceRequest;
+
+DescribeRegionResourceRequest::DescribeRegionResourceRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DescribeRegionResource") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeRegionResourceRequest::~DescribeRegionResourceRequest() {}
+
+std::string DescribeRegionResourceRequest::getIspType() const {
+  return ispType_;
+}
+
+void DescribeRegionResourceRequest::setIspType(const std::string &ispType) {
+  ispType_ = ispType;
+  setParameter(std::string("IspType"), ispType);
+}
+
+std::string DescribeRegionResourceRequest::getEnsRegionId() const {
+  return ensRegionId_;
+}
+
+void DescribeRegionResourceRequest::setEnsRegionId(const std::string &ensRegionId) {
+  ensRegionId_ = ensRegionId;
+  setParameter(std::string("EnsRegionId"), ensRegionId);
+}
+
+std::string DescribeRegionResourceRequest::getOpenapiCheck() const {
+  return openapiCheck_;
+}
+
+void DescribeRegionResourceRequest::setOpenapiCheck(const std::string &openapiCheck) {
+  openapiCheck_ = openapiCheck;
+  setParameter(std::string("OpenapiCheck"), openapiCheck);
+}
+

ens/src/model/DescribeRegionResourceResult.cc

@@ -0,0 +1,483 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeRegionResourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+DescribeRegionResourceResult::DescribeRegionResourceResult() :
+	ServiceResult()
+{}
+
+DescribeRegionResourceResult::DescribeRegionResourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRegionResourceResult::~DescribeRegionResourceResult()
+{}
+
+void DescribeRegionResourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["dataItem"];
+	for (auto valueDatadataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDatadataItem["AreaCode"].isNull())
+			dataObject.areaCode = valueDatadataItem["AreaCode"].asString();
+		if(!valueDatadataItem["AreaName"].isNull())
+			dataObject.areaName = valueDatadataItem["AreaName"].asString();
+		if(!valueDatadataItem["CountryCode"].isNull())
+			dataObject.countryCode = valueDatadataItem["CountryCode"].asString();
+		if(!valueDatadataItem["CountryName"].isNull())
+			dataObject.countryName = valueDatadataItem["CountryName"].asString();
+		if(!valueDatadataItem["HouseId"].isNull())
+			dataObject.houseId = valueDatadataItem["HouseId"].asString();
+		if(!valueDatadataItem["Name"].isNull())
+			dataObject.name = valueDatadataItem["Name"].asString();
+		if(!valueDatadataItem["Poc"].isNull())
+			dataObject.poc = valueDatadataItem["Poc"].asString() == "true";
+		if(!valueDatadataItem["ProvinceCode"].isNull())
+			dataObject.provinceCode = valueDatadataItem["ProvinceCode"].asString();
+		if(!valueDatadataItem["ProvinceName"].isNull())
+			dataObject.provinceName = valueDatadataItem["ProvinceName"].asString();
+		if(!valueDatadataItem["ReserveDisable"].isNull())
+			dataObject.reserveDisable = valueDatadataItem["ReserveDisable"].asString() == "true";
+		if(!valueDatadataItem["StatusDisable"].isNull())
+			dataObject.statusDisable = valueDatadataItem["StatusDisable"].asString() == "true";
+		if(!valueDatadataItem["Type"].isNull())
+			dataObject.type = valueDatadataItem["Type"].asString();
+		if(!valueDatadataItem["Uuid"].isNull())
+			dataObject.uuid = valueDatadataItem["Uuid"].asString();
+		if(!valueDatadataItem["Virtual"].isNull())
+			dataObject._virtual = valueDatadataItem["Virtual"].asString();
+		auto allIpv4sNode = valueDatadataItem["Ipv4s"]["ipv4sItem"];
+		for (auto valueDatadataItemIpv4sipv4sItem : allIpv4sNode)
+		{
+			DataItem::Ipv4sItem ipv4sObject;
+			if(!valueDatadataItemIpv4sipv4sItem["Display"].isNull())
+				ipv4sObject.display = valueDatadataItemIpv4sipv4sItem["Display"].asString();
+			if(!valueDatadataItemIpv4sipv4sItem["Isp"].isNull())
+				ipv4sObject.isp = valueDatadataItemIpv4sipv4sItem["Isp"].asString();
+			if(!valueDatadataItemIpv4sipv4sItem["OversellRatio"].isNull())
+				ipv4sObject.oversellRatio = std::stol(valueDatadataItemIpv4sipv4sItem["OversellRatio"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["Remain"].isNull())
+				ipv4sObject.remain = std::stol(valueDatadataItemIpv4sipv4sItem["Remain"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["Reserved"].isNull())
+				ipv4sObject.reserved = std::stol(valueDatadataItemIpv4sipv4sItem["Reserved"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["ReserveDisable"].isNull())
+				ipv4sObject.reserveDisable = valueDatadataItemIpv4sipv4sItem["ReserveDisable"].asString() == "true";
+			if(!valueDatadataItemIpv4sipv4sItem["ReserveDisableTotal"].isNull())
+				ipv4sObject.reserveDisableTotal = std::stol(valueDatadataItemIpv4sipv4sItem["ReserveDisableTotal"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["StatusDisable"].isNull())
+				ipv4sObject.statusDisable = valueDatadataItemIpv4sipv4sItem["StatusDisable"].asString() == "true";
+			if(!valueDatadataItemIpv4sipv4sItem["StatusDisableTotal"].isNull())
+				ipv4sObject.statusDisableTotal = std::stol(valueDatadataItemIpv4sipv4sItem["StatusDisableTotal"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["Total"].isNull())
+				ipv4sObject.total = std::stol(valueDatadataItemIpv4sipv4sItem["Total"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["Type"].isNull())
+				ipv4sObject.type = valueDatadataItemIpv4sipv4sItem["Type"].asString();
+			if(!valueDatadataItemIpv4sipv4sItem["Used"].isNull())
+				ipv4sObject.used = std::stol(valueDatadataItemIpv4sipv4sItem["Used"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["UsedRatio"].isNull())
+				ipv4sObject.usedRatio = std::stol(valueDatadataItemIpv4sipv4sItem["UsedRatio"].asString());
+			if(!valueDatadataItemIpv4sipv4sItem["Vlan"].isNull())
+				ipv4sObject.vlan = valueDatadataItemIpv4sipv4sItem["Vlan"].asString();
+			dataObject.ipv4s.push_back(ipv4sObject);
+		}
+		auto allIpv6sNode = valueDatadataItem["Ipv6s"]["ipv6sItem"];
+		for (auto valueDatadataItemIpv6sipv6sItem : allIpv6sNode)
+		{
+			DataItem::Ipv6sItem ipv6sObject;
+			if(!valueDatadataItemIpv6sipv6sItem["Display"].isNull())
+				ipv6sObject.display = valueDatadataItemIpv6sipv6sItem["Display"].asString();
+			if(!valueDatadataItemIpv6sipv6sItem["Isp"].isNull())
+				ipv6sObject.isp = valueDatadataItemIpv6sipv6sItem["Isp"].asString();
+			if(!valueDatadataItemIpv6sipv6sItem["OversellRatio"].isNull())
+				ipv6sObject.oversellRatio = std::stol(valueDatadataItemIpv6sipv6sItem["OversellRatio"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["Remain"].isNull())
+				ipv6sObject.remain = std::stol(valueDatadataItemIpv6sipv6sItem["Remain"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["Reserved"].isNull())
+				ipv6sObject.reserved = std::stol(valueDatadataItemIpv6sipv6sItem["Reserved"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["ReserveDisable"].isNull())
+				ipv6sObject.reserveDisable = valueDatadataItemIpv6sipv6sItem["ReserveDisable"].asString() == "true";
+			if(!valueDatadataItemIpv6sipv6sItem["ReserveDisableTotal"].isNull())
+				ipv6sObject.reserveDisableTotal = std::stol(valueDatadataItemIpv6sipv6sItem["ReserveDisableTotal"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["StatusDisable"].isNull())
+				ipv6sObject.statusDisable = valueDatadataItemIpv6sipv6sItem["StatusDisable"].asString() == "true";
+			if(!valueDatadataItemIpv6sipv6sItem["StatusDisableTotal"].isNull())
+				ipv6sObject.statusDisableTotal = std::stol(valueDatadataItemIpv6sipv6sItem["StatusDisableTotal"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["Total"].isNull())
+				ipv6sObject.total = std::stol(valueDatadataItemIpv6sipv6sItem["Total"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["Type"].isNull())
+				ipv6sObject.type = valueDatadataItemIpv6sipv6sItem["Type"].asString();
+			if(!valueDatadataItemIpv6sipv6sItem["Used"].isNull())
+				ipv6sObject.used = std::stol(valueDatadataItemIpv6sipv6sItem["Used"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["UsedRatio"].isNull())
+				ipv6sObject.usedRatio = std::stol(valueDatadataItemIpv6sipv6sItem["UsedRatio"].asString());
+			if(!valueDatadataItemIpv6sipv6sItem["Vlan"].isNull())
+				ipv6sObject.vlan = valueDatadataItemIpv6sipv6sItem["Vlan"].asString();
+			dataObject.ipv6s.push_back(ipv6sObject);
+		}
+		auto armCardNode = value["ArmCard"];
+		if(!armCardNode["Display"].isNull())
+			dataObject.armCard.display = armCardNode["Display"].asString() == "true";
+		if(!armCardNode["OversellRatio"].isNull())
+			dataObject.armCard.oversellRatio = std::stol(armCardNode["OversellRatio"].asString());
+		if(!armCardNode["Remain"].isNull())
+			dataObject.armCard.remain = std::stol(armCardNode["Remain"].asString());
+		if(!armCardNode["Reserved"].isNull())
+			dataObject.armCard.reserved = std::stol(armCardNode["Reserved"].asString());
+		if(!armCardNode["ReserveDisable"].isNull())
+			dataObject.armCard.reserveDisable = armCardNode["ReserveDisable"].asString() == "true";
+		if(!armCardNode["ReserveDisableTotal"].isNull())
+			dataObject.armCard.reserveDisableTotal = std::stol(armCardNode["ReserveDisableTotal"].asString());
+		if(!armCardNode["StatusDisable"].isNull())
+			dataObject.armCard.statusDisable = armCardNode["StatusDisable"].asString() == "true";
+		if(!armCardNode["StatusDisableTotal"].isNull())
+			dataObject.armCard.statusDisableTotal = std::stol(armCardNode["StatusDisableTotal"].asString());
+		if(!armCardNode["Total"].isNull())
+			dataObject.armCard.total = std::stol(armCardNode["Total"].asString());
+		if(!armCardNode["Type"].isNull())
+			dataObject.armCard.type = armCardNode["Type"].asString();
+		if(!armCardNode["Used"].isNull())
+			dataObject.armCard.used = std::stol(armCardNode["Used"].asString());
+		if(!armCardNode["UsedRatio"].isNull())
+			dataObject.armCard.usedRatio = std::stol(armCardNode["UsedRatio"].asString());
+		auto bandwidthNode = value["Bandwidth"];
+		if(!bandwidthNode["Display"].isNull())
+			dataObject.bandwidth.display = bandwidthNode["Display"].asString() == "true";
+		if(!bandwidthNode["OversellRatio"].isNull())
+			dataObject.bandwidth.oversellRatio = std::stol(bandwidthNode["OversellRatio"].asString());
+		if(!bandwidthNode["Remain"].isNull())
+			dataObject.bandwidth.remain = std::stol(bandwidthNode["Remain"].asString());
+		if(!bandwidthNode["Reserved"].isNull())
+			dataObject.bandwidth.reserved = std::stol(bandwidthNode["Reserved"].asString());
+		if(!bandwidthNode["ReserveDisable"].isNull())
+			dataObject.bandwidth.reserveDisable = bandwidthNode["ReserveDisable"].asString() == "true";
+		if(!bandwidthNode["ReserveDisableTotal"].isNull())
+			dataObject.bandwidth.reserveDisableTotal = std::stol(bandwidthNode["ReserveDisableTotal"].asString());
+		if(!bandwidthNode["StatusDisable"].isNull())
+			dataObject.bandwidth.statusDisable = bandwidthNode["StatusDisable"].asString() == "true";
+		if(!bandwidthNode["StatusDisableTotal"].isNull())
+			dataObject.bandwidth.statusDisableTotal = std::stol(bandwidthNode["StatusDisableTotal"].asString());
+		if(!bandwidthNode["Total"].isNull())
+			dataObject.bandwidth.total = std::stol(bandwidthNode["Total"].asString());
+		if(!bandwidthNode["Type"].isNull())
+			dataObject.bandwidth.type = bandwidthNode["Type"].asString();
+		if(!bandwidthNode["Used"].isNull())
+			dataObject.bandwidth.used = std::stol(bandwidthNode["Used"].asString());
+		if(!bandwidthNode["UsedRatio"].isNull())
+			dataObject.bandwidth.usedRatio = std::stol(bandwidthNode["UsedRatio"].asString());
+		auto blockStorageNode = value["BlockStorage"];
+		if(!blockStorageNode["Display"].isNull())
+			dataObject.blockStorage.display = blockStorageNode["Display"].asString() == "true";
+		if(!blockStorageNode["OversellRatio"].isNull())
+			dataObject.blockStorage.oversellRatio = std::stol(blockStorageNode["OversellRatio"].asString());
+		if(!blockStorageNode["Remain"].isNull())
+			dataObject.blockStorage.remain = std::stol(blockStorageNode["Remain"].asString());
+		if(!blockStorageNode["Reserved"].isNull())
+			dataObject.blockStorage.reserved = std::stol(blockStorageNode["Reserved"].asString());
+		if(!blockStorageNode["ReserveDisable"].isNull())
+			dataObject.blockStorage.reserveDisable = blockStorageNode["ReserveDisable"].asString() == "true";
+		if(!blockStorageNode["ReserveDisableTotal"].isNull())
+			dataObject.blockStorage.reserveDisableTotal = std::stol(blockStorageNode["ReserveDisableTotal"].asString());
+		if(!blockStorageNode["StatusDisable"].isNull())
+			dataObject.blockStorage.statusDisable = blockStorageNode["StatusDisable"].asString() == "true";
+		if(!blockStorageNode["StatusDisableTotal"].isNull())
+			dataObject.blockStorage.statusDisableTotal = std::stol(blockStorageNode["StatusDisableTotal"].asString());
+		if(!blockStorageNode["Total"].isNull())
+			dataObject.blockStorage.total = std::stol(blockStorageNode["Total"].asString());
+		if(!blockStorageNode["Type"].isNull())
+			dataObject.blockStorage.type = blockStorageNode["Type"].asString();
+		if(!blockStorageNode["Used"].isNull())
+			dataObject.blockStorage.used = std::stol(blockStorageNode["Used"].asString());
+		if(!blockStorageNode["UsedRatio"].isNull())
+			dataObject.blockStorage.usedRatio = std::stol(blockStorageNode["UsedRatio"].asString());
+		auto cpuNode = value["Cpu"];
+		if(!cpuNode["Display"].isNull())
+			dataObject.cpu.display = cpuNode["Display"].asString() == "true";
+		if(!cpuNode["OversellRatio"].isNull())
+			dataObject.cpu.oversellRatio = std::stol(cpuNode["OversellRatio"].asString());
+		if(!cpuNode["Remain"].isNull())
+			dataObject.cpu.remain = std::stol(cpuNode["Remain"].asString());
+		if(!cpuNode["Reserved"].isNull())
+			dataObject.cpu.reserved = std::stol(cpuNode["Reserved"].asString());
+		if(!cpuNode["ReserveDisable"].isNull())
+			dataObject.cpu.reserveDisable = cpuNode["ReserveDisable"].asString() == "true";
+		if(!cpuNode["ReserveDisableTotal"].isNull())
+			dataObject.cpu.reserveDisableTotal = std::stol(cpuNode["ReserveDisableTotal"].asString());
+		if(!cpuNode["StatusDisable"].isNull())
+			dataObject.cpu.statusDisable = cpuNode["StatusDisable"].asString() == "true";
+		if(!cpuNode["StatusDisableTotal"].isNull())
+			dataObject.cpu.statusDisableTotal = std::stol(cpuNode["StatusDisableTotal"].asString());
+		if(!cpuNode["Total"].isNull())
+			dataObject.cpu.total = std::stol(cpuNode["Total"].asString());
+		if(!cpuNode["Type"].isNull())
+			dataObject.cpu.type = cpuNode["Type"].asString();
+		if(!cpuNode["Used"].isNull())
+			dataObject.cpu.used = std::stol(cpuNode["Used"].asString());
+		if(!cpuNode["UsedRatio"].isNull())
+			dataObject.cpu.usedRatio = std::stol(cpuNode["UsedRatio"].asString());
+		auto memoryNode = value["Memory"];
+		if(!memoryNode["Display"].isNull())
+			dataObject.memory.display = memoryNode["Display"].asString() == "true";
+		if(!memoryNode["OversellRatio"].isNull())
+			dataObject.memory.oversellRatio = std::stol(memoryNode["OversellRatio"].asString());
+		if(!memoryNode["Remain"].isNull())
+			dataObject.memory.remain = std::stol(memoryNode["Remain"].asString());
+		if(!memoryNode["Reserved"].isNull())
+			dataObject.memory.reserved = std::stol(memoryNode["Reserved"].asString());
+		if(!memoryNode["ReserveDisable"].isNull())
+			dataObject.memory.reserveDisable = memoryNode["ReserveDisable"].asString() == "true";
+		if(!memoryNode["ReserveDisableTotal"].isNull())
+			dataObject.memory.reserveDisableTotal = std::stol(memoryNode["ReserveDisableTotal"].asString());
+		if(!memoryNode["StatusDisable"].isNull())
+			dataObject.memory.statusDisable = memoryNode["StatusDisable"].asString() == "true";
+		if(!memoryNode["StatusDisableTotal"].isNull())
+			dataObject.memory.statusDisableTotal = std::stol(memoryNode["StatusDisableTotal"].asString());
+		if(!memoryNode["Total"].isNull())
+			dataObject.memory.total = std::stol(memoryNode["Total"].asString());
+		if(!memoryNode["Type"].isNull())
+			dataObject.memory.type = memoryNode["Type"].asString();
+		if(!memoryNode["Used"].isNull())
+			dataObject.memory.used = std::stol(memoryNode["Used"].asString());
+		if(!memoryNode["UsedRatio"].isNull())
+			dataObject.memory.usedRatio = std::stol(memoryNode["UsedRatio"].asString());
+		auto gpuNode = value["Gpu"];
+		if(!gpuNode["Display"].isNull())
+			dataObject.gpu.display = gpuNode["Display"].asString() == "true";
+		if(!gpuNode["OversellRatio"].isNull())
+			dataObject.gpu.oversellRatio = std::stol(gpuNode["OversellRatio"].asString());
+		if(!gpuNode["Remain"].isNull())
+			dataObject.gpu.remain = std::stol(gpuNode["Remain"].asString());
+		if(!gpuNode["Reserved"].isNull())
+			dataObject.gpu.reserved = std::stol(gpuNode["Reserved"].asString());
+		if(!gpuNode["ReserveDisable"].isNull())
+			dataObject.gpu.reserveDisable = gpuNode["ReserveDisable"].asString() == "true";
+		if(!gpuNode["ReserveDisableTotal"].isNull())
+			dataObject.gpu.reserveDisableTotal = std::stol(gpuNode["ReserveDisableTotal"].asString());
+		if(!gpuNode["StatusDisable"].isNull())
+			dataObject.gpu.statusDisable = gpuNode["StatusDisable"].asString() == "true";
+		if(!gpuNode["StatusDisableTotal"].isNull())
+			dataObject.gpu.statusDisableTotal = std::stol(gpuNode["StatusDisableTotal"].asString());
+		if(!gpuNode["Total"].isNull())
+			dataObject.gpu.total = std::stol(gpuNode["Total"].asString());
+		if(!gpuNode["Type"].isNull())
+			dataObject.gpu.type = gpuNode["Type"].asString();
+		if(!gpuNode["Used"].isNull())
+			dataObject.gpu.used = std::stol(gpuNode["Used"].asString());
+		if(!gpuNode["UsedRatio"].isNull())
+			dataObject.gpu.usedRatio = std::stol(gpuNode["UsedRatio"].asString());
+		auto hddNode = value["Hdd"];
+		if(!hddNode["Display"].isNull())
+			dataObject.hdd.display = hddNode["Display"].asString() == "true";
+		if(!hddNode["OversellRatio"].isNull())
+			dataObject.hdd.oversellRatio = std::stol(hddNode["OversellRatio"].asString());
+		if(!hddNode["Remain"].isNull())
+			dataObject.hdd.remain = std::stol(hddNode["Remain"].asString());
+		if(!hddNode["Reserved"].isNull())
+			dataObject.hdd.reserved = std::stol(hddNode["Reserved"].asString());
+		if(!hddNode["ReserveDisable"].isNull())
+			dataObject.hdd.reserveDisable = hddNode["ReserveDisable"].asString() == "true";
+		if(!hddNode["ReserveDisableTotal"].isNull())
+			dataObject.hdd.reserveDisableTotal = std::stol(hddNode["ReserveDisableTotal"].asString());
+		if(!hddNode["StatusDisable"].isNull())
+			dataObject.hdd.statusDisable = hddNode["StatusDisable"].asString() == "true";
+		if(!hddNode["StatusDisableTotal"].isNull())
+			dataObject.hdd.statusDisableTotal = std::stol(hddNode["StatusDisableTotal"].asString());
+		if(!hddNode["Total"].isNull())
+			dataObject.hdd.total = std::stol(hddNode["Total"].asString());
+		if(!hddNode["Type"].isNull())
+			dataObject.hdd.type = hddNode["Type"].asString();
+		if(!hddNode["Used"].isNull())
+			dataObject.hdd.used = std::stol(hddNode["Used"].asString());
+		if(!hddNode["UsedRatio"].isNull())
+			dataObject.hdd.usedRatio = std::stol(hddNode["UsedRatio"].asString());
+		auto ssdNode = value["Ssd"];
+		if(!ssdNode["Display"].isNull())
+			dataObject.ssd.display = ssdNode["Display"].asString() == "true";
+		if(!ssdNode["OversellRatio"].isNull())
+			dataObject.ssd.oversellRatio = std::stol(ssdNode["OversellRatio"].asString());
+		if(!ssdNode["Remain"].isNull())
+			dataObject.ssd.remain = std::stol(ssdNode["Remain"].asString());
+		if(!ssdNode["Reserved"].isNull())
+			dataObject.ssd.reserved = std::stol(ssdNode["Reserved"].asString());
+		if(!ssdNode["ReserveDisable"].isNull())
+			dataObject.ssd.reserveDisable = ssdNode["ReserveDisable"].asString() == "true";
+		if(!ssdNode["ReserveDisableTotal"].isNull())
+			dataObject.ssd.reserveDisableTotal = std::stol(ssdNode["ReserveDisableTotal"].asString());
+		if(!ssdNode["StatusDisable"].isNull())
+			dataObject.ssd.statusDisable = ssdNode["StatusDisable"].asString() == "true";
+		if(!ssdNode["StatusDisableTotal"].isNull())
+			dataObject.ssd.statusDisableTotal = std::stol(ssdNode["StatusDisableTotal"].asString());
+		if(!ssdNode["Total"].isNull())
+			dataObject.ssd.total = std::stol(ssdNode["Total"].asString());
+		if(!ssdNode["Type"].isNull())
+			dataObject.ssd.type = ssdNode["Type"].asString();
+		if(!ssdNode["Used"].isNull())
+			dataObject.ssd.used = std::stol(ssdNode["Used"].asString());
+		if(!ssdNode["UsedRatio"].isNull())
+			dataObject.ssd.usedRatio = std::stol(ssdNode["UsedRatio"].asString());
+		auto nvmeNode = value["Nvme"];
+		if(!nvmeNode["Display"].isNull())
+			dataObject.nvme.display = nvmeNode["Display"].asString() == "true";
+		if(!nvmeNode["OversellRatio"].isNull())
+			dataObject.nvme.oversellRatio = std::stol(nvmeNode["OversellRatio"].asString());
+		if(!nvmeNode["Remain"].isNull())
+			dataObject.nvme.remain = std::stol(nvmeNode["Remain"].asString());
+		if(!nvmeNode["Reserved"].isNull())
+			dataObject.nvme.reserved = std::stol(nvmeNode["Reserved"].asString());
+		if(!nvmeNode["ReserveDisable"].isNull())
+			dataObject.nvme.reserveDisable = nvmeNode["ReserveDisable"].asString() == "true";
+		if(!nvmeNode["ReserveDisableTotal"].isNull())
+			dataObject.nvme.reserveDisableTotal = std::stol(nvmeNode["ReserveDisableTotal"].asString());
+		if(!nvmeNode["StatusDisable"].isNull())
+			dataObject.nvme.statusDisable = nvmeNode["StatusDisable"].asString() == "true";
+		if(!nvmeNode["StatusDisableTotal"].isNull())
+			dataObject.nvme.statusDisableTotal = std::stol(nvmeNode["StatusDisableTotal"].asString());
+		if(!nvmeNode["Total"].isNull())
+			dataObject.nvme.total = std::stol(nvmeNode["Total"].asString());
+		if(!nvmeNode["Type"].isNull())
+			dataObject.nvme.type = nvmeNode["Type"].asString();
+		if(!nvmeNode["Used"].isNull())
+			dataObject.nvme.used = std::stol(nvmeNode["Used"].asString());
+		if(!nvmeNode["UsedRatio"].isNull())
+			dataObject.nvme.usedRatio = std::stol(nvmeNode["UsedRatio"].asString());
+		auto ossStorageNode = value["OssStorage"];
+		if(!ossStorageNode["Display"].isNull())
+			dataObject.ossStorage.display = ossStorageNode["Display"].asString() == "true";
+		if(!ossStorageNode["OversellRatio"].isNull())
+			dataObject.ossStorage.oversellRatio = std::stol(ossStorageNode["OversellRatio"].asString());
+		if(!ossStorageNode["Remain"].isNull())
+			dataObject.ossStorage.remain = std::stol(ossStorageNode["Remain"].asString());
+		if(!ossStorageNode["Reserved"].isNull())
+			dataObject.ossStorage.reserved = std::stol(ossStorageNode["Reserved"].asString());
+		if(!ossStorageNode["ReserveDisable"].isNull())
+			dataObject.ossStorage.reserveDisable = ossStorageNode["ReserveDisable"].asString() == "true";
+		if(!ossStorageNode["ReserveDisableTotal"].isNull())
+			dataObject.ossStorage.reserveDisableTotal = std::stol(ossStorageNode["ReserveDisableTotal"].asString());
+		if(!ossStorageNode["StatusDisable"].isNull())
+			dataObject.ossStorage.statusDisable = ossStorageNode["StatusDisable"].asString() == "true";
+		if(!ossStorageNode["StatusDisableTotal"].isNull())
+			dataObject.ossStorage.statusDisableTotal = std::stol(ossStorageNode["StatusDisableTotal"].asString());
+		if(!ossStorageNode["Total"].isNull())
+			dataObject.ossStorage.total = std::stol(ossStorageNode["Total"].asString());
+		if(!ossStorageNode["Type"].isNull())
+			dataObject.ossStorage.type = ossStorageNode["Type"].asString();
+		if(!ossStorageNode["Used"].isNull())
+			dataObject.ossStorage.used = std::stol(ossStorageNode["Used"].asString());
+		if(!ossStorageNode["UsedRatio"].isNull())
+			dataObject.ossStorage.usedRatio = std::stol(ossStorageNode["UsedRatio"].asString());
+		auto panguNode = value["Pangu"];
+		if(!panguNode["Display"].isNull())
+			dataObject.pangu.display = panguNode["Display"].asString() == "true";
+		if(!panguNode["OversellRatio"].isNull())
+			dataObject.pangu.oversellRatio = std::stol(panguNode["OversellRatio"].asString());
+		if(!panguNode["Remain"].isNull())
+			dataObject.pangu.remain = std::stol(panguNode["Remain"].asString());
+		if(!panguNode["Reserved"].isNull())
+			dataObject.pangu.reserved = std::stol(panguNode["Reserved"].asString());
+		if(!panguNode["ReserveDisable"].isNull())
+			dataObject.pangu.reserveDisable = panguNode["ReserveDisable"].asString() == "true";
+		if(!panguNode["ReserveDisableTotal"].isNull())
+			dataObject.pangu.reserveDisableTotal = std::stol(panguNode["ReserveDisableTotal"].asString());
+		if(!panguNode["StatusDisable"].isNull())
+			dataObject.pangu.statusDisable = panguNode["StatusDisable"].asString() == "true";
+		if(!panguNode["StatusDisableTotal"].isNull())
+			dataObject.pangu.statusDisableTotal = std::stol(panguNode["StatusDisableTotal"].asString());
+		if(!panguNode["Total"].isNull())
+			dataObject.pangu.total = std::stol(panguNode["Total"].asString());
+		if(!panguNode["Type"].isNull())
+			dataObject.pangu.type = panguNode["Type"].asString();
+		if(!panguNode["Used"].isNull())
+			dataObject.pangu.used = std::stol(panguNode["Used"].asString());
+		if(!panguNode["UsedRatio"].isNull())
+			dataObject.pangu.usedRatio = std::stol(panguNode["UsedRatio"].asString());
+		auto pcfarmNumNode = value["PcfarmNum"];
+		if(!pcfarmNumNode["Display"].isNull())
+			dataObject.pcfarmNum.display = pcfarmNumNode["Display"].asString() == "true";
+		if(!pcfarmNumNode["OversellRatio"].isNull())
+			dataObject.pcfarmNum.oversellRatio = std::stol(pcfarmNumNode["OversellRatio"].asString());
+		if(!pcfarmNumNode["Remain"].isNull())
+			dataObject.pcfarmNum.remain = std::stol(pcfarmNumNode["Remain"].asString());
+		if(!pcfarmNumNode["Reserved"].isNull())
+			dataObject.pcfarmNum.reserved = std::stol(pcfarmNumNode["Reserved"].asString());
+		if(!pcfarmNumNode["ReserveDisable"].isNull())
+			dataObject.pcfarmNum.reserveDisable = pcfarmNumNode["ReserveDisable"].asString() == "true";
+		if(!pcfarmNumNode["ReserveDisableTotal"].isNull())
+			dataObject.pcfarmNum.reserveDisableTotal = std::stol(pcfarmNumNode["ReserveDisableTotal"].asString());
+		if(!pcfarmNumNode["StatusDisable"].isNull())
+			dataObject.pcfarmNum.statusDisable = pcfarmNumNode["StatusDisable"].asString() == "true";
+		if(!pcfarmNumNode["StatusDisableTotal"].isNull())
+			dataObject.pcfarmNum.statusDisableTotal = std::stol(pcfarmNumNode["StatusDisableTotal"].asString());
+		if(!pcfarmNumNode["Total"].isNull())
+			dataObject.pcfarmNum.total = std::stol(pcfarmNumNode["Total"].asString());
+		if(!pcfarmNumNode["Type"].isNull())
+			dataObject.pcfarmNum.type = pcfarmNumNode["Type"].asString();
+		if(!pcfarmNumNode["Used"].isNull())
+			dataObject.pcfarmNum.used = std::stol(pcfarmNumNode["Used"].asString());
+		if(!pcfarmNumNode["UsedRatio"].isNull())
+			dataObject.pcfarmNum.usedRatio = std::stol(pcfarmNumNode["UsedRatio"].asString());
+		auto allAttributes = value["Attributes"]["attributes"];
+		for (auto value : allAttributes)
+			dataObject.attributes.push_back(value.asString());
+		auto allIspTypes = value["IspTypes"]["ispTypes"];
+		for (auto value : allIspTypes)
+			dataObject.ispTypes.push_back(value.asString());
+		data_.push_back(dataObject);
+	}
+	auto pagerNode = value["Pager"];
+	if(!pagerNode["Page"].isNull())
+		pager_.page = std::stol(pagerNode["Page"].asString());
+	if(!pagerNode["Size"].isNull())
+		pager_.size = std::stol(pagerNode["Size"].asString());
+	if(!pagerNode["Total"].isNull())
+		pager_.total = std::stol(pagerNode["Total"].asString());
+	if(!value["Msg"].isNull())
+		msg_ = value["Msg"].asString();
+	if(!value["Desc"].isNull())
+		desc_ = value["Desc"].asString();
+
+}
+
+std::string DescribeRegionResourceResult::getMsg()const
+{
+	return msg_;
+}
+
+std::string DescribeRegionResourceResult::getDesc()const
+{
+	return desc_;
+}
+
+DescribeRegionResourceResult::Pager DescribeRegionResourceResult::getPager()const
+{
+	return pager_;
+}
+
+std::vector<DescribeRegionResourceResult::DataItem> DescribeRegionResourceResult::getData()const
+{
+	return data_;
+}
+

ens/src/model/DescribeResourceTimelineRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeResourceTimelineRequest.h>
+
+using AlibabaCloud::Ens::Model::DescribeResourceTimelineRequest;
+
+DescribeResourceTimelineRequest::DescribeResourceTimelineRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "DescribeResourceTimeline") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DescribeResourceTimelineRequest::~DescribeResourceTimelineRequest() {}
+
+std::string DescribeResourceTimelineRequest::getUuid() const {
+  return uuid_;
+}
+
+void DescribeResourceTimelineRequest::setUuid(const std::string &uuid) {
+  uuid_ = uuid;
+  setParameter(std::string("Uuid"), uuid);
+}
+
+std::string DescribeResourceTimelineRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeResourceTimelineRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeResourceTimelineRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void DescribeResourceTimelineRequest::setBeginTime(const std::string &beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), beginTime);
+}
+
+std::string DescribeResourceTimelineRequest::getOpenapiCheck() const {
+  return openapiCheck_;
+}
+
+void DescribeResourceTimelineRequest::setOpenapiCheck(const std::string &openapiCheck) {
+  openapiCheck_ = openapiCheck;
+  setParameter(std::string("OpenapiCheck"), openapiCheck);
+}
+

ens/src/model/DescribeResourceTimelineResult.cc

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/DescribeResourceTimelineResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+DescribeResourceTimelineResult::DescribeResourceTimelineResult() :
+	ServiceResult()
+{}
+
+DescribeResourceTimelineResult::DescribeResourceTimelineResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeResourceTimelineResult::~DescribeResourceTimelineResult()
+{}
+
+void DescribeResourceTimelineResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAvailableEventsNode = value["AvailableEvents"]["可用性事件"];
+	for (auto valueAvailableEvents可用性事件 : allAvailableEventsNode)
+	{
+		可用性事件 availableEventsObject;
+		if(!valueAvailableEvents可用性事件["Name"].isNull())
+			availableEventsObject.name = valueAvailableEvents可用性事件["Name"].asString();
+		if(!valueAvailableEvents可用性事件["OccurrenceTime"].isNull())
+			availableEventsObject.occurrenceTime = valueAvailableEvents可用性事件["OccurrenceTime"].asString();
+		if(!valueAvailableEvents可用性事件["Reason"].isNull())
+			availableEventsObject.reason = valueAvailableEvents可用性事件["Reason"].asString();
+		if(!valueAvailableEvents可用性事件["Type"].isNull())
+			availableEventsObject.type = valueAvailableEvents可用性事件["Type"].asString();
+		availableEvents_.push_back(availableEventsObject);
+	}
+	auto allBizEventsNode = value["BizEvents"]["建设状态事件"];
+	for (auto valueBizEvents建设状态事件 : allBizEventsNode)
+	{
+		建设状态事件 bizEventsObject;
+		if(!valueBizEvents建设状态事件["Name"].isNull())
+			bizEventsObject.name = valueBizEvents建设状态事件["Name"].asString();
+		if(!valueBizEvents建设状态事件["OccurrenceTime"].isNull())
+			bizEventsObject.occurrenceTime = valueBizEvents建设状态事件["OccurrenceTime"].asString();
+		if(!valueBizEvents建设状态事件["Reason"].isNull())
+			bizEventsObject.reason = valueBizEvents建设状态事件["Reason"].asString();
+		if(!valueBizEvents建设状态事件["Type"].isNull())
+			bizEventsObject.type = valueBizEvents建设状态事件["Type"].asString();
+		bizEvents_.push_back(bizEventsObject);
+	}
+	auto allInventoryEventsNode = value["InventoryEvents"]["资源扣减事件"];
+	for (auto valueInventoryEvents资源扣减事件 : allInventoryEventsNode)
+	{
+		资源扣减事件 inventoryEventsObject;
+		if(!valueInventoryEvents资源扣减事件["Name"].isNull())
+			inventoryEventsObject.name = valueInventoryEvents资源扣减事件["Name"].asString();
+		if(!valueInventoryEvents资源扣减事件["OccurrenceTime"].isNull())
+			inventoryEventsObject.occurrenceTime = valueInventoryEvents资源扣减事件["OccurrenceTime"].asString();
+		if(!valueInventoryEvents资源扣减事件["Reason"].isNull())
+			inventoryEventsObject.reason = valueInventoryEvents资源扣减事件["Reason"].asString();
+		if(!valueInventoryEvents资源扣减事件["Type"].isNull())
+			inventoryEventsObject.type = valueInventoryEvents资源扣减事件["Type"].asString();
+		inventoryEvents_.push_back(inventoryEventsObject);
+	}
+	auto allReserveEventsNode = value["ReserveEvents"]["资源预留事件"];
+	for (auto valueReserveEvents资源预留事件 : allReserveEventsNode)
+	{
+		资源预留事件 reserveEventsObject;
+		if(!valueReserveEvents资源预留事件["Name"].isNull())
+			reserveEventsObject.name = valueReserveEvents资源预留事件["Name"].asString();
+		if(!valueReserveEvents资源预留事件["OccurrenceTime"].isNull())
+			reserveEventsObject.occurrenceTime = valueReserveEvents资源预留事件["OccurrenceTime"].asString();
+		if(!valueReserveEvents资源预留事件["Reason"].isNull())
+			reserveEventsObject.reason = valueReserveEvents资源预留事件["Reason"].asString();
+		if(!valueReserveEvents资源预留事件["Type"].isNull())
+			reserveEventsObject.type = valueReserveEvents资源预留事件["Type"].asString();
+		reserveEvents_.push_back(reserveEventsObject);
+	}
+	if(!value["Msg"].isNull())
+		msg_ = value["Msg"].asString();
+	if(!value["Desc"].isNull())
+		desc_ = value["Desc"].asString();
+
+}
+
+std::string DescribeResourceTimelineResult::getMsg()const
+{
+	return msg_;
+}
+
+std::string DescribeResourceTimelineResult::getDesc()const
+{
+	return desc_;
+}
+
+std::vector<DescribeResourceTimelineResult::资源扣减事件> DescribeResourceTimelineResult::getInventoryEvents()const
+{
+	return inventoryEvents_;
+}
+
+std::vector<DescribeResourceTimelineResult::可用性事件> DescribeResourceTimelineResult::getAvailableEvents()const
+{
+	return availableEvents_;
+}
+
+std::vector<DescribeResourceTimelineResult::建设状态事件> DescribeResourceTimelineResult::getBizEvents()const
+{
+	return bizEvents_;
+}
+
+std::vector<DescribeResourceTimelineResult::资源预留事件> DescribeResourceTimelineResult::getReserveEvents()const
+{
+	return reserveEvents_;
+}
+

ens/src/model/ModifyInstanceAttributeRequest.cc

@@ -25,6 +25,15 @@ ModifyInstanceAttributeRequest::ModifyInstanceAttributeRequest()
 
 ModifyInstanceAttributeRequest::~ModifyInstanceAttributeRequest() {}
 
+std::string ModifyInstanceAttributeRequest::getUserData() const {
+  return userData_;
+}
+
+void ModifyInstanceAttributeRequest::setUserData(const std::string &userData) {
+  userData_ = userData;
+  setParameter(std::string("UserData"), userData);
+}
+
 std::string ModifyInstanceAttributeRequest::getPassword() const {
   return password_;
 }
@@ -34,6 +43,15 @@ void ModifyInstanceAttributeRequest::setPassword(const std::string &password) {
   setParameter(std::string("Password"), password);
 }
 
+std::string ModifyInstanceAttributeRequest::getHostName() const {
+  return hostName_;
+}
+
+void ModifyInstanceAttributeRequest::setHostName(const std::string &hostName) {
+  hostName_ = hostName;
+  setParameter(std::string("HostName"), hostName);
+}
+
 std::string ModifyInstanceAttributeRequest::getInstanceId() const {
   return instanceId_;
 }

ens/src/model/RebootInstancesRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/RebootInstancesRequest.h>
+
+using AlibabaCloud::Ens::Model::RebootInstancesRequest;
+
+RebootInstancesRequest::RebootInstancesRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "RebootInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RebootInstancesRequest::~RebootInstancesRequest() {}
+
+std::vector<RebootInstancesRequest::std::string> RebootInstancesRequest::getInstanceIds() const {
+  return instanceIds_;
+}
+
+void RebootInstancesRequest::setInstanceIds(const std::vector<RebootInstancesRequest::std::string> &instanceIds) {
+  instanceIds_ = instanceIds;
+  for(int dep1 = 0; dep1 != instanceIds.size(); dep1++) {
+    setParameter(std::string("InstanceIds") + "." + std::to_string(dep1 + 1), instanceIds[dep1]);
+  }
+}
+

ens/src/model/RebootInstancesResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/RebootInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+RebootInstancesResult::RebootInstancesResult() :
+	ServiceResult()
+{}
+
+RebootInstancesResult::RebootInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RebootInstancesResult::~RebootInstancesResult()
+{}
+
+void RebootInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceResponsesNode = value["InstanceResponses"]["InstanceResponsesItem"];
+	for (auto valueInstanceResponsesInstanceResponsesItem : allInstanceResponsesNode)
+	{
+		InstanceResponsesItem instanceResponsesObject;
+		if(!valueInstanceResponsesInstanceResponsesItem["Code"].isNull())
+			instanceResponsesObject.code = std::stol(valueInstanceResponsesInstanceResponsesItem["Code"].asString());
+		if(!valueInstanceResponsesInstanceResponsesItem["Message"].isNull())
+			instanceResponsesObject.message = valueInstanceResponsesInstanceResponsesItem["Message"].asString();
+		if(!valueInstanceResponsesInstanceResponsesItem["InstanceId"].isNull())
+			instanceResponsesObject.instanceId = valueInstanceResponsesInstanceResponsesItem["InstanceId"].asString();
+		instanceResponses_.push_back(instanceResponsesObject);
+	}
+
+}
+
+std::vector<RebootInstancesResult::InstanceResponsesItem> RebootInstancesResult::getInstanceResponses()const
+{
+	return instanceResponses_;
+}
+

ens/src/model/ReinitInstancesRequest.cc

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/ReinitInstancesRequest.h>
+
+using AlibabaCloud::Ens::Model::ReinitInstancesRequest;
+
+ReinitInstancesRequest::ReinitInstancesRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "ReinitInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ReinitInstancesRequest::~ReinitInstancesRequest() {}
+
+std::string ReinitInstancesRequest::getImageId() const {
+  return imageId_;
+}
+
+void ReinitInstancesRequest::setImageId(const std::string &imageId) {
+  imageId_ = imageId;
+  setParameter(std::string("ImageId"), imageId);
+}
+
+std::string ReinitInstancesRequest::getPassword() const {
+  return password_;
+}
+
+void ReinitInstancesRequest::setPassword(const std::string &password) {
+  password_ = password;
+  setParameter(std::string("Password"), password);
+}
+
+std::vector<ReinitInstancesRequest::std::string> ReinitInstancesRequest::getInstanceIds() const {
+  return instanceIds_;
+}
+
+void ReinitInstancesRequest::setInstanceIds(const std::vector<ReinitInstancesRequest::std::string> &instanceIds) {
+  instanceIds_ = instanceIds;
+  for(int dep1 = 0; dep1 != instanceIds.size(); dep1++) {
+    setParameter(std::string("InstanceIds") + "." + std::to_string(dep1 + 1), instanceIds[dep1]);
+  }
+}
+

ens/src/model/ReinitInstancesResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/ReinitInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+ReinitInstancesResult::ReinitInstancesResult() :
+	ServiceResult()
+{}
+
+ReinitInstancesResult::ReinitInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ReinitInstancesResult::~ReinitInstancesResult()
+{}
+
+void ReinitInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceResponsesNode = value["InstanceResponses"]["InstanceResponsesItem"];
+	for (auto valueInstanceResponsesInstanceResponsesItem : allInstanceResponsesNode)
+	{
+		InstanceResponsesItem instanceResponsesObject;
+		if(!valueInstanceResponsesInstanceResponsesItem["Code"].isNull())
+			instanceResponsesObject.code = std::stol(valueInstanceResponsesInstanceResponsesItem["Code"].asString());
+		if(!valueInstanceResponsesInstanceResponsesItem["Message"].isNull())
+			instanceResponsesObject.message = valueInstanceResponsesInstanceResponsesItem["Message"].asString();
+		if(!valueInstanceResponsesInstanceResponsesItem["InstanceId"].isNull())
+			instanceResponsesObject.instanceId = valueInstanceResponsesInstanceResponsesItem["InstanceId"].asString();
+		instanceResponses_.push_back(instanceResponsesObject);
+	}
+
+}
+
+std::vector<ReinitInstancesResult::InstanceResponsesItem> ReinitInstancesResult::getInstanceResponses()const
+{
+	return instanceResponses_;
+}
+

ens/src/model/StartInstancesRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/StartInstancesRequest.h>
+
+using AlibabaCloud::Ens::Model::StartInstancesRequest;
+
+StartInstancesRequest::StartInstancesRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "StartInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+StartInstancesRequest::~StartInstancesRequest() {}
+
+std::vector<StartInstancesRequest::std::string> StartInstancesRequest::getInstanceIds() const {
+  return instanceIds_;
+}
+
+void StartInstancesRequest::setInstanceIds(const std::vector<StartInstancesRequest::std::string> &instanceIds) {
+  instanceIds_ = instanceIds;
+  for(int dep1 = 0; dep1 != instanceIds.size(); dep1++) {
+    setParameter(std::string("InstanceIds") + "." + std::to_string(dep1 + 1), instanceIds[dep1]);
+  }
+}
+

ens/src/model/StartInstancesResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/StartInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+StartInstancesResult::StartInstancesResult() :
+	ServiceResult()
+{}
+
+StartInstancesResult::StartInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+StartInstancesResult::~StartInstancesResult()
+{}
+
+void StartInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceResponsesNode = value["InstanceResponses"]["InstanceResponsesItem"];
+	for (auto valueInstanceResponsesInstanceResponsesItem : allInstanceResponsesNode)
+	{
+		InstanceResponsesItem instanceResponsesObject;
+		if(!valueInstanceResponsesInstanceResponsesItem["Code"].isNull())
+			instanceResponsesObject.code = std::stol(valueInstanceResponsesInstanceResponsesItem["Code"].asString());
+		if(!valueInstanceResponsesInstanceResponsesItem["Message"].isNull())
+			instanceResponsesObject.message = valueInstanceResponsesInstanceResponsesItem["Message"].asString();
+		if(!valueInstanceResponsesInstanceResponsesItem["InstanceId"].isNull())
+			instanceResponsesObject.instanceId = valueInstanceResponsesInstanceResponsesItem["InstanceId"].asString();
+		instanceResponses_.push_back(instanceResponsesObject);
+	}
+
+}
+
+std::vector<StartInstancesResult::InstanceResponsesItem> StartInstancesResult::getInstanceResponses()const
+{
+	return instanceResponses_;
+}
+

ens/src/model/StopInstancesRequest.cc

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/StopInstancesRequest.h>
+
+using AlibabaCloud::Ens::Model::StopInstancesRequest;
+
+StopInstancesRequest::StopInstancesRequest()
+    : RpcServiceRequest("ens", "2017-11-10", "StopInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+StopInstancesRequest::~StopInstancesRequest() {}
+
+std::vector<StopInstancesRequest::std::string> StopInstancesRequest::getInstanceIds() const {
+  return instanceIds_;
+}
+
+void StopInstancesRequest::setInstanceIds(const std::vector<StopInstancesRequest::std::string> &instanceIds) {
+  instanceIds_ = instanceIds;
+  for(int dep1 = 0; dep1 != instanceIds.size(); dep1++) {
+    setParameter(std::string("InstanceIds") + "." + std::to_string(dep1 + 1), instanceIds[dep1]);
+  }
+}
+

ens/src/model/StopInstancesResult.cc

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ens/model/StopInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Ens;
+using namespace AlibabaCloud::Ens::Model;
+
+StopInstancesResult::StopInstancesResult() :
+	ServiceResult()
+{}
+
+StopInstancesResult::StopInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+StopInstancesResult::~StopInstancesResult()
+{}
+
+void StopInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstanceResponsesNode = value["InstanceResponses"]["InstanceResponsesItem"];
+	for (auto valueInstanceResponsesInstanceResponsesItem : allInstanceResponsesNode)
+	{
+		InstanceResponsesItem instanceResponsesObject;
+		if(!valueInstanceResponsesInstanceResponsesItem["Code"].isNull())
+			instanceResponsesObject.code = std::stol(valueInstanceResponsesInstanceResponsesItem["Code"].asString());
+		if(!valueInstanceResponsesInstanceResponsesItem["Message"].isNull())
+			instanceResponsesObject.message = valueInstanceResponsesInstanceResponsesItem["Message"].asString();
+		if(!valueInstanceResponsesInstanceResponsesItem["InstanceId"].isNull())
+			instanceResponsesObject.instanceId = valueInstanceResponsesInstanceResponsesItem["InstanceId"].asString();
+		instanceResponses_.push_back(instanceResponsesObject);
+	}
+
+}
+
+std::vector<StopInstancesResult::InstanceResponsesItem> StopInstancesResult::getInstanceResponses()const
+{
+	return instanceResponses_;
+}
+