Generate SDK for service instance APIs.

VERSION

@@ -1 +1 @@
-1.36.1572
+1.36.1573

computenest/CMakeLists.txt

@@ -0,0 +1,110 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(computenest_public_header 
+	include/alibabacloud/computenest/ComputeNestClient.h
+	include/alibabacloud/computenest/ComputeNestExport.h )
+
+set(computenest_public_header_model 
+	include/alibabacloud/computenest/model/ContinueDeployServiceInstanceRequest.h
+	include/alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h
+	include/alibabacloud/computenest/model/CreateServiceInstanceRequest.h
+	include/alibabacloud/computenest/model/CreateServiceInstanceResult.h
+	include/alibabacloud/computenest/model/DeleteServiceInstancesRequest.h
+	include/alibabacloud/computenest/model/DeleteServiceInstancesResult.h
+	include/alibabacloud/computenest/model/GetServiceInstanceRequest.h
+	include/alibabacloud/computenest/model/GetServiceInstanceResult.h
+	include/alibabacloud/computenest/model/ListServiceInstanceLogsRequest.h
+	include/alibabacloud/computenest/model/ListServiceInstanceLogsResult.h
+	include/alibabacloud/computenest/model/ListServiceInstanceResourcesRequest.h
+	include/alibabacloud/computenest/model/ListServiceInstanceResourcesResult.h
+	include/alibabacloud/computenest/model/ListServiceInstancesRequest.h
+	include/alibabacloud/computenest/model/ListServiceInstancesResult.h )
+
+set(computenest_src 
+	src/ComputeNestClient.cc
+	src/model/ContinueDeployServiceInstanceRequest.cc
+	src/model/ContinueDeployServiceInstanceResult.cc
+	src/model/CreateServiceInstanceRequest.cc
+	src/model/CreateServiceInstanceResult.cc
+	src/model/DeleteServiceInstancesRequest.cc
+	src/model/DeleteServiceInstancesResult.cc
+	src/model/GetServiceInstanceRequest.cc
+	src/model/GetServiceInstanceResult.cc
+	src/model/ListServiceInstanceLogsRequest.cc
+	src/model/ListServiceInstanceLogsResult.cc
+	src/model/ListServiceInstanceResourcesRequest.cc
+	src/model/ListServiceInstanceResourcesResult.cc
+	src/model/ListServiceInstancesRequest.cc
+	src/model/ListServiceInstancesResult.cc )
+
+add_library(computenest ${LIB_TYPE}
+	${computenest_public_header}
+	${computenest_public_header_model}
+	${computenest_src})
+
+set_target_properties(computenest
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}computenest
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(computenest
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_COMPUTENEST_LIBRARY)
+endif()
+
+target_include_directories(computenest
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(computenest
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(computenest
+		jsoncpp)
+	target_include_directories(computenest
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(computenest
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(computenest
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(computenest
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(computenest
+		jsoncpp)
+endif()
+
+install(FILES ${computenest_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenest)
+install(FILES ${computenest_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenest/model)
+install(TARGETS computenest
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

computenest/include/alibabacloud/computenest/ComputeNestClient.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENEST_COMPUTENESTCLIENT_H_
+#define ALIBABACLOUD_COMPUTENEST_COMPUTENESTCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ComputeNestExport.h"
+#include "model/ContinueDeployServiceInstanceRequest.h"
+#include "model/ContinueDeployServiceInstanceResult.h"
+#include "model/CreateServiceInstanceRequest.h"
+#include "model/CreateServiceInstanceResult.h"
+#include "model/DeleteServiceInstancesRequest.h"
+#include "model/DeleteServiceInstancesResult.h"
+#include "model/GetServiceInstanceRequest.h"
+#include "model/GetServiceInstanceResult.h"
+#include "model/ListServiceInstanceLogsRequest.h"
+#include "model/ListServiceInstanceLogsResult.h"
+#include "model/ListServiceInstanceResourcesRequest.h"
+#include "model/ListServiceInstanceResourcesResult.h"
+#include "model/ListServiceInstancesRequest.h"
+#include "model/ListServiceInstancesResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		class ALIBABACLOUD_COMPUTENEST_EXPORT ComputeNestClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::ContinueDeployServiceInstanceResult> ContinueDeployServiceInstanceOutcome;
+			typedef std::future<ContinueDeployServiceInstanceOutcome> ContinueDeployServiceInstanceOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::ContinueDeployServiceInstanceRequest&, const ContinueDeployServiceInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ContinueDeployServiceInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreateServiceInstanceResult> CreateServiceInstanceOutcome;
+			typedef std::future<CreateServiceInstanceOutcome> CreateServiceInstanceOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::CreateServiceInstanceRequest&, const CreateServiceInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServiceInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteServiceInstancesResult> DeleteServiceInstancesOutcome;
+			typedef std::future<DeleteServiceInstancesOutcome> DeleteServiceInstancesOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::DeleteServiceInstancesRequest&, const DeleteServiceInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServiceInstancesAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceInstanceResult> GetServiceInstanceOutcome;
+			typedef std::future<GetServiceInstanceOutcome> GetServiceInstanceOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::GetServiceInstanceRequest&, const GetServiceInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ListServiceInstanceLogsResult> ListServiceInstanceLogsOutcome;
+			typedef std::future<ListServiceInstanceLogsOutcome> ListServiceInstanceLogsOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::ListServiceInstanceLogsRequest&, const ListServiceInstanceLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceInstanceLogsAsyncHandler;
+			typedef Outcome<Error, Model::ListServiceInstanceResourcesResult> ListServiceInstanceResourcesOutcome;
+			typedef std::future<ListServiceInstanceResourcesOutcome> ListServiceInstanceResourcesOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::ListServiceInstanceResourcesRequest&, const ListServiceInstanceResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceInstanceResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListServiceInstancesResult> ListServiceInstancesOutcome;
+			typedef std::future<ListServiceInstancesOutcome> ListServiceInstancesOutcomeCallable;
+			typedef std::function<void(const ComputeNestClient*, const Model::ListServiceInstancesRequest&, const ListServiceInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceInstancesAsyncHandler;
+
+			ComputeNestClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ComputeNestClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ComputeNestClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ComputeNestClient();
+			ContinueDeployServiceInstanceOutcome continueDeployServiceInstance(const Model::ContinueDeployServiceInstanceRequest &request)const;
+			void continueDeployServiceInstanceAsync(const Model::ContinueDeployServiceInstanceRequest& request, const ContinueDeployServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ContinueDeployServiceInstanceOutcomeCallable continueDeployServiceInstanceCallable(const Model::ContinueDeployServiceInstanceRequest& request) const;
+			CreateServiceInstanceOutcome createServiceInstance(const Model::CreateServiceInstanceRequest &request)const;
+			void createServiceInstanceAsync(const Model::CreateServiceInstanceRequest& request, const CreateServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServiceInstanceOutcomeCallable createServiceInstanceCallable(const Model::CreateServiceInstanceRequest& request) const;
+			DeleteServiceInstancesOutcome deleteServiceInstances(const Model::DeleteServiceInstancesRequest &request)const;
+			void deleteServiceInstancesAsync(const Model::DeleteServiceInstancesRequest& request, const DeleteServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteServiceInstancesOutcomeCallable deleteServiceInstancesCallable(const Model::DeleteServiceInstancesRequest& request) const;
+			GetServiceInstanceOutcome getServiceInstance(const Model::GetServiceInstanceRequest &request)const;
+			void getServiceInstanceAsync(const Model::GetServiceInstanceRequest& request, const GetServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetServiceInstanceOutcomeCallable getServiceInstanceCallable(const Model::GetServiceInstanceRequest& request) const;
+			ListServiceInstanceLogsOutcome listServiceInstanceLogs(const Model::ListServiceInstanceLogsRequest &request)const;
+			void listServiceInstanceLogsAsync(const Model::ListServiceInstanceLogsRequest& request, const ListServiceInstanceLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServiceInstanceLogsOutcomeCallable listServiceInstanceLogsCallable(const Model::ListServiceInstanceLogsRequest& request) const;
+			ListServiceInstanceResourcesOutcome listServiceInstanceResources(const Model::ListServiceInstanceResourcesRequest &request)const;
+			void listServiceInstanceResourcesAsync(const Model::ListServiceInstanceResourcesRequest& request, const ListServiceInstanceResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServiceInstanceResourcesOutcomeCallable listServiceInstanceResourcesCallable(const Model::ListServiceInstanceResourcesRequest& request) const;
+			ListServiceInstancesOutcome listServiceInstances(const Model::ListServiceInstancesRequest &request)const;
+			void listServiceInstancesAsync(const Model::ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListServiceInstancesOutcomeCallable listServiceInstancesCallable(const Model::ListServiceInstancesRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_COMPUTENEST_COMPUTENESTCLIENT_H_

computenest/include/alibabacloud/computenest/ComputeNestExport.h

@@ -0,0 +1,32 @@
+/*
+ * 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_COMPUTENEST_COMPUTENESTEXPORT_H_
+#define ALIBABACLOUD_COMPUTENEST_COMPUTENESTEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_COMPUTENEST_LIBRARY)
+#		define ALIBABACLOUD_COMPUTENEST_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_COMPUTENEST_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_COMPUTENEST_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_COMPUTENEST_COMPUTENESTEXPORT_H_

computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceRequest.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_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCEREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT ContinueDeployServiceInstanceRequest : public RpcServiceRequest {
+public:
+	ContinueDeployServiceInstanceRequest();
+	~ContinueDeployServiceInstanceRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getServiceInstanceId() const;
+	void setServiceInstanceId(const std::string &serviceInstanceId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getParameters() const;
+	void setParameters(const std::string &parameters);
+	std::vector<std::string> getOption() const;
+	void setOption(const std::vector<std::string> &option);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::string serviceInstanceId_;
+	bool dryRun_;
+	std::string parameters_;
+	std::vector<std::string> option_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCEREQUEST_H_

computenest/include/alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCERESULT_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenest/ComputeNestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENEST_EXPORT ContinueDeployServiceInstanceResult : public ServiceResult
+			{
+			public:
+				struct DryRunResult
+				{
+					std::vector<std::string> parametersNotAllowedToBeModified;
+					std::vector<std::string> parametersConditionallyAllowedToBeModified;
+					std::vector<std::string> parametersAllowedToBeModified;
+				};
+
+
+				ContinueDeployServiceInstanceResult();
+				explicit ContinueDeployServiceInstanceResult(const std::string &payload);
+				~ContinueDeployServiceInstanceResult();
+				std::string getServiceInstanceId()const;
+				DryRunResult getDryRunResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string serviceInstanceId_;
+				DryRunResult dryRunResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CONTINUEDEPLOYSERVICEINSTANCERESULT_H_

computenest/include/alibabacloud/computenest/model/CreateServiceInstanceRequest.h

@@ -0,0 +1,111 @@
+/*
+ * 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_COMPUTENEST_MODEL_CREATESERVICEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCEREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT CreateServiceInstanceRequest : public RpcServiceRequest {
+public:
+	struct Commodity {
+		long payPeriod;
+		std::string payPeriodUnit;
+	};
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	struct OperationMetadata {
+		std::string endTime;
+		std::string resources;
+		std::string startTime;
+		std::string extraInfo;
+		std::string serviceInstanceId;
+	};
+	CreateServiceInstanceRequest();
+	~CreateServiceInstanceRequest();
+	Commodity getCommodity() const;
+	void setCommodity(const Commodity &commodity);
+	std::string getContactGroup() const;
+	void setContactGroup(const std::string &contactGroup);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getSpecificationCode() const;
+	void setSpecificationCode(const std::string &specificationCode);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	bool getEnableInstanceOps() const;
+	void setEnableInstanceOps(bool enableInstanceOps);
+	std::string getTemplateName() const;
+	void setTemplateName(const std::string &templateName);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	bool getEnableUserPrometheus() const;
+	void setEnableUserPrometheus(bool enableUserPrometheus);
+	std::string getSpecificationName() const;
+	void setSpecificationName(const std::string &specificationName);
+	std::string getTrialType() const;
+	void setTrialType(const std::string &trialType);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getServiceVersion() const;
+	void setServiceVersion(const std::string &serviceVersion);
+	std::string getServiceId() const;
+	void setServiceId(const std::string &serviceId);
+	std::string getParameters() const;
+	void setParameters(const std::string &parameters);
+	long getPayType() const;
+	void setPayType(long payType);
+	OperationMetadata getOperationMetadata() const;
+	void setOperationMetadata(const OperationMetadata &operationMetadata);
+
+private:
+	Commodity commodity_;
+	std::string contactGroup_;
+	std::string clientToken_;
+	std::string specificationCode_;
+	std::string resourceGroupId_;
+	std::string regionId_;
+	bool enableInstanceOps_;
+	std::string templateName_;
+	std::vector<Tag> tag_;
+	bool dryRun_;
+	bool enableUserPrometheus_;
+	std::string specificationName_;
+	std::string trialType_;
+	std::string name_;
+	std::string serviceVersion_;
+	std::string serviceId_;
+	std::string parameters_;
+	long payType_;
+	OperationMetadata operationMetadata_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCEREQUEST_H_

computenest/include/alibabacloud/computenest/model/CreateServiceInstanceResult.h

@@ -0,0 +1,55 @@
+/*
+ * 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_COMPUTENEST_MODEL_CREATESERVICEINSTANCERESULT_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenest/ComputeNestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENEST_EXPORT CreateServiceInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServiceInstanceResult();
+				explicit CreateServiceInstanceResult(const std::string &payload);
+				~CreateServiceInstanceResult();
+				std::string getStatus()const;
+				std::string getServiceInstanceId()const;
+				std::string getMarketInstanceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string serviceInstanceId_;
+				std::string marketInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_CREATESERVICEINSTANCERESULT_H_

computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesRequest.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_COMPUTENEST_MODEL_DELETESERVICEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT DeleteServiceInstancesRequest : public RpcServiceRequest {
+public:
+	DeleteServiceInstancesRequest();
+	~DeleteServiceInstancesRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getServiceInstanceId() const;
+	void setServiceInstanceId(const std::vector<std::string> &serviceInstanceId);
+
+private:
+	std::string clientToken_;
+	std::string regionId_;
+	std::vector<std::string> serviceInstanceId_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_DELETESERVICEINSTANCESREQUEST_H_

computenest/include/alibabacloud/computenest/model/DeleteServiceInstancesResult.h

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

computenest/include/alibabacloud/computenest/model/GetServiceInstanceRequest.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_COMPUTENEST_MODEL_GETSERVICEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCEREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT GetServiceInstanceRequest : public RpcServiceRequest {
+public:
+	GetServiceInstanceRequest();
+	~GetServiceInstanceRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getServiceInstanceId() const;
+	void setServiceInstanceId(const std::string &serviceInstanceId);
+	std::string getMarketInstanceId() const;
+	void setMarketInstanceId(const std::string &marketInstanceId);
+
+private:
+	std::string regionId_;
+	std::string serviceInstanceId_;
+	std::string marketInstanceId_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCEREQUEST_H_

computenest/include/alibabacloud/computenest/model/GetServiceInstanceResult.h

@@ -0,0 +1,172 @@
+/*
+ * 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_COMPUTENEST_MODEL_GETSERVICEINSTANCERESULT_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenest/ComputeNestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENEST_EXPORT GetServiceInstanceResult : public ServiceResult
+			{
+			public:
+				struct Service
+				{
+					struct ServiceInfo
+					{
+						std::string locale;
+						std::string image;
+						std::string name;
+						std::string shortDescription;
+					};
+					std::string status;
+					std::string deployType;
+					std::vector<std::string> upgradableServiceVersions;
+					std::string serviceId;
+					std::string deployMetadata;
+					std::string version;
+					std::string supplierName;
+					std::string serviceType;
+					std::vector<ServiceInfo> serviceInfos;
+					std::string publishTime;
+					std::string versionName;
+					std::string serviceProductUrl;
+					std::string supplierUrl;
+					std::string upgradeMetadata;
+					std::string serviceDocUrl;
+				};
+				struct NetworkConfig
+				{
+					struct PrivateVpcConnection
+					{
+						struct ConnectionConfig
+						{
+							std::vector<std::string> securityGroups;
+							std::vector<std::string> endpointIps;
+							std::string ingressEndpointStatus;
+							std::string vpcId;
+							std::string domainName;
+							std::string networkServiceStatus;
+							int connectBandwidth;
+							std::vector<std::string> vSwitches;
+							std::string regionId;
+						};
+						std::string privateZoneName;
+						std::vector<PrivateVpcConnection::ConnectionConfig> connectionConfigs;
+						std::string endpointId;
+						std::string regionId;
+						std::string privateZoneId;
+					};
+					struct ReversePrivateVpcConnection
+					{
+						std::string endpointId;
+					};
+					std::vector<ReversePrivateVpcConnection> reversePrivateVpcConnections;
+					std::string endpointId;
+					std::vector<PrivateVpcConnection> privateVpcConnections;
+					std::string privateZoneId;
+				};
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+
+
+				GetServiceInstanceResult();
+				explicit GetServiceInstanceResult(const std::string &payload);
+				~GetServiceInstanceResult();
+				std::string getOperatedServiceInstanceId()const;
+				std::string getEndTime()const;
+				std::string getResourceGroupId()const;
+				std::string getOperationEndTime()const;
+				bool getEnableInstanceOps()const;
+				std::string getPredefinedParameterName()const;
+				std::string getSource()const;
+				std::string getName()const;
+				std::string getComponents()const;
+				std::string getOperationStartTime()const;
+				std::string getServiceInstanceId()const;
+				std::string getServiceType()const;
+				std::string getTemplateName()const;
+				std::string getMarketInstanceId()const;
+				std::vector<Tag> getTags()const;
+				std::string getStatus()const;
+				long getProgress()const;
+				std::string getParameters()const;
+				std::string getCreateTime()const;
+				NetworkConfig getNetworkConfig()const;
+				Service getService()const;
+				std::string getPayType()const;
+				std::string getLicenseEndTime()const;
+				long getUserId()const;
+				bool getEnableUserPrometheus()const;
+				std::string getStatusDetail()const;
+				std::string getOutputs()const;
+				std::string getUpdateTime()const;
+				bool getIsOperated()const;
+				long getSupplierUid()const;
+				std::string getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string operatedServiceInstanceId_;
+				std::string endTime_;
+				std::string resourceGroupId_;
+				std::string operationEndTime_;
+				bool enableInstanceOps_;
+				std::string predefinedParameterName_;
+				std::string source_;
+				std::string name_;
+				std::string components_;
+				std::string operationStartTime_;
+				std::string serviceInstanceId_;
+				std::string serviceType_;
+				std::string templateName_;
+				std::string marketInstanceId_;
+				std::vector<Tag> tags_;
+				std::string status_;
+				long progress_;
+				std::string parameters_;
+				std::string createTime_;
+				NetworkConfig networkConfig_;
+				Service service_;
+				std::string payType_;
+				std::string licenseEndTime_;
+				long userId_;
+				bool enableUserPrometheus_;
+				std::string statusDetail_;
+				std::string outputs_;
+				std::string updateTime_;
+				bool isOperated_;
+				long supplierUid_;
+				std::string resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_GETSERVICEINSTANCERESULT_H_

computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsRequest.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_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceLogsRequest : public RpcServiceRequest {
+public:
+	ListServiceInstanceLogsRequest();
+	~ListServiceInstanceLogsRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getServiceInstanceId() const;
+	void setServiceInstanceId(const std::string &serviceInstanceId);
+	std::string getMaxResults() const;
+	void setMaxResults(const std::string &maxResults);
+
+private:
+	std::string regionId_;
+	std::string nextToken_;
+	std::string serviceInstanceId_;
+	std::string maxResults_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSREQUEST_H_

computenest/include/alibabacloud/computenest/model/ListServiceInstanceLogsResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSRESULT_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenest/ComputeNestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceLogsResult : public ServiceResult
+			{
+			public:
+				struct ServiceInstanceLogs
+				{
+					std::string status;
+					std::string serviceInstanceId;
+					std::string resourceId;
+					std::string content;
+					std::string logType;
+					std::string resourceType;
+					std::string timestamp;
+					std::string source;
+				};
+
+
+				ListServiceInstanceLogsResult();
+				explicit ListServiceInstanceLogsResult(const std::string &payload);
+				~ListServiceInstanceLogsResult();
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+				std::vector<ServiceInstanceLogs> getServiceInstancesLogs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string maxResults_;
+				std::vector<ServiceInstanceLogs> serviceInstancesLogs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCELOGSRESULT_H_

computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesRequest.h

@@ -0,0 +1,70 @@
+/*
+ * 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_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceResourcesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	ListServiceInstanceResourcesRequest();
+	~ListServiceInstanceResourcesRequest();
+	std::string getExpireTimeEnd() const;
+	void setExpireTimeEnd(const std::string &expireTimeEnd);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getResourceARN() const;
+	void setResourceARN(const std::vector<std::string> &resourceARN);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::string getServiceInstanceId() const;
+	void setServiceInstanceId(const std::string &serviceInstanceId);
+	std::string getExpireTimeStart() const;
+	void setExpireTimeStart(const std::string &expireTimeStart);
+	std::string getMaxResults() const;
+	void setMaxResults(const std::string &maxResults);
+	std::string getPayType() const;
+	void setPayType(const std::string &payType);
+
+private:
+	std::string expireTimeEnd_;
+	std::string nextToken_;
+	std::string regionId_;
+	std::vector<std::string> resourceARN_;
+	std::vector<Tag> tag_;
+	std::string serviceInstanceId_;
+	std::string expireTimeStart_;
+	std::string maxResults_;
+	std::string payType_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESREQUEST_H_

computenest/include/alibabacloud/computenest/model/ListServiceInstanceResourcesResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESRESULT_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenest/ComputeNestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstanceResourcesResult : public ServiceResult
+			{
+			public:
+				struct ResourcesItem
+				{
+					std::string resourceARN;
+					std::string productCode;
+					std::string renewalPeriodUnit;
+					std::string createTime;
+					std::string productType;
+					std::string payType;
+					std::string expireTime;
+					std::string renewStatus;
+					int renewalPeriod;
+				};
+
+
+				ListServiceInstanceResourcesResult();
+				explicit ListServiceInstanceResourcesResult(const std::string &payload);
+				~ListServiceInstanceResourcesResult();
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+				std::vector<ResourcesItem> getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string maxResults_;
+				std::vector<ResourcesItem> resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCERESOURCESRESULT_H_

computenest/include/alibabacloud/computenest/model/ListServiceInstancesRequest.h

@@ -0,0 +1,64 @@
+/*
+ * 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_COMPUTENEST_MODEL_LISTSERVICEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESREQUEST_H_
+
+#include <alibabacloud/computenest/ComputeNestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNest {
+namespace Model {
+class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstancesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	struct Filter {
+		std::string name;
+	};
+	ListServiceInstancesRequest();
+	~ListServiceInstancesRequest();
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	std::vector<Filter> getFilter() const;
+	void setFilter(const std::vector<Filter> &filter);
+	std::string getMaxResults() const;
+	void setMaxResults(const std::string &maxResults);
+
+private:
+	std::string resourceGroupId_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::vector<Tag> tag_;
+	std::vector<Filter> filter_;
+	std::string maxResults_;
+};
+} // namespace Model
+} // namespace ComputeNest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESREQUEST_H_

computenest/include/alibabacloud/computenest/model/ListServiceInstancesResult.h

@@ -0,0 +1,108 @@
+/*
+ * 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_COMPUTENEST_MODEL_LISTSERVICEINSTANCESRESULT_H_
+#define ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenest/ComputeNestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENEST_EXPORT ListServiceInstancesResult : public ServiceResult
+			{
+			public:
+				struct ServiceInstance
+				{
+					struct Service
+					{
+						struct ServiceInfo
+						{
+							std::string locale;
+							std::string image;
+							std::string name;
+							std::string shortDescription;
+						};
+						std::string status;
+						std::string deployType;
+						std::string version;
+						std::string supplierName;
+						std::string serviceType;
+						std::vector<ServiceInfo> serviceInfos;
+						std::string publishTime;
+						std::string versionName;
+						std::string supplierUrl;
+						std::string serviceId;
+					};
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::string status;
+					std::string operatedServiceInstanceId;
+					long progress;
+					std::string parameters;
+					std::string endTime;
+					std::string resourceGroupId;
+					std::string operationEndTime;
+					std::string createTime;
+					bool enableInstanceOps;
+					Service service;
+					std::string payType;
+					std::string source;
+					std::string name;
+					std::string operationStartTime;
+					std::string serviceInstanceId;
+					std::string serviceType;
+					std::string statusDetail;
+					std::string outputs;
+					std::string updateTime;
+					std::string templateName;
+					std::string resources;
+					std::string marketInstanceId;
+					std::vector<ServiceInstance::Tag> tags;
+				};
+
+
+				ListServiceInstancesResult();
+				explicit ListServiceInstancesResult(const std::string &payload);
+				~ListServiceInstancesResult();
+				long getTotalCount()const;
+				std::vector<ServiceInstance> getServiceInstances()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::vector<ServiceInstance> serviceInstances_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENEST_MODEL_LISTSERVICEINSTANCESRESULT_H_

computenest/src/ComputeNestClient.cc

@@ -0,0 +1,305 @@
+/*
+ * 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/computenest/ComputeNestClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "ComputeNest";
+}
+
+ComputeNestClient::ComputeNestClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "computenest");
+}
+
+ComputeNestClient::ComputeNestClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "computenest");
+}
+
+ComputeNestClient::ComputeNestClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "computenest");
+}
+
+ComputeNestClient::~ComputeNestClient()
+{}
+
+ComputeNestClient::ContinueDeployServiceInstanceOutcome ComputeNestClient::continueDeployServiceInstance(const ContinueDeployServiceInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ContinueDeployServiceInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ContinueDeployServiceInstanceOutcome(ContinueDeployServiceInstanceResult(outcome.result()));
+	else
+		return ContinueDeployServiceInstanceOutcome(outcome.error());
+}
+
+void ComputeNestClient::continueDeployServiceInstanceAsync(const ContinueDeployServiceInstanceRequest& request, const ContinueDeployServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, continueDeployServiceInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::ContinueDeployServiceInstanceOutcomeCallable ComputeNestClient::continueDeployServiceInstanceCallable(const ContinueDeployServiceInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ContinueDeployServiceInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->continueDeployServiceInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestClient::CreateServiceInstanceOutcome ComputeNestClient::createServiceInstance(const CreateServiceInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServiceInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServiceInstanceOutcome(CreateServiceInstanceResult(outcome.result()));
+	else
+		return CreateServiceInstanceOutcome(outcome.error());
+}
+
+void ComputeNestClient::createServiceInstanceAsync(const CreateServiceInstanceRequest& request, const CreateServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServiceInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::CreateServiceInstanceOutcomeCallable ComputeNestClient::createServiceInstanceCallable(const CreateServiceInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServiceInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->createServiceInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestClient::DeleteServiceInstancesOutcome ComputeNestClient::deleteServiceInstances(const DeleteServiceInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteServiceInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteServiceInstancesOutcome(DeleteServiceInstancesResult(outcome.result()));
+	else
+		return DeleteServiceInstancesOutcome(outcome.error());
+}
+
+void ComputeNestClient::deleteServiceInstancesAsync(const DeleteServiceInstancesRequest& request, const DeleteServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteServiceInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::DeleteServiceInstancesOutcomeCallable ComputeNestClient::deleteServiceInstancesCallable(const DeleteServiceInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteServiceInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteServiceInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestClient::GetServiceInstanceOutcome ComputeNestClient::getServiceInstance(const GetServiceInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetServiceInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetServiceInstanceOutcome(GetServiceInstanceResult(outcome.result()));
+	else
+		return GetServiceInstanceOutcome(outcome.error());
+}
+
+void ComputeNestClient::getServiceInstanceAsync(const GetServiceInstanceRequest& request, const GetServiceInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getServiceInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::GetServiceInstanceOutcomeCallable ComputeNestClient::getServiceInstanceCallable(const GetServiceInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetServiceInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->getServiceInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestClient::ListServiceInstanceLogsOutcome ComputeNestClient::listServiceInstanceLogs(const ListServiceInstanceLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServiceInstanceLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServiceInstanceLogsOutcome(ListServiceInstanceLogsResult(outcome.result()));
+	else
+		return ListServiceInstanceLogsOutcome(outcome.error());
+}
+
+void ComputeNestClient::listServiceInstanceLogsAsync(const ListServiceInstanceLogsRequest& request, const ListServiceInstanceLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServiceInstanceLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::ListServiceInstanceLogsOutcomeCallable ComputeNestClient::listServiceInstanceLogsCallable(const ListServiceInstanceLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServiceInstanceLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->listServiceInstanceLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestClient::ListServiceInstanceResourcesOutcome ComputeNestClient::listServiceInstanceResources(const ListServiceInstanceResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServiceInstanceResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServiceInstanceResourcesOutcome(ListServiceInstanceResourcesResult(outcome.result()));
+	else
+		return ListServiceInstanceResourcesOutcome(outcome.error());
+}
+
+void ComputeNestClient::listServiceInstanceResourcesAsync(const ListServiceInstanceResourcesRequest& request, const ListServiceInstanceResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServiceInstanceResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::ListServiceInstanceResourcesOutcomeCallable ComputeNestClient::listServiceInstanceResourcesCallable(const ListServiceInstanceResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServiceInstanceResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->listServiceInstanceResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestClient::ListServiceInstancesOutcome ComputeNestClient::listServiceInstances(const ListServiceInstancesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListServiceInstancesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListServiceInstancesOutcome(ListServiceInstancesResult(outcome.result()));
+	else
+		return ListServiceInstancesOutcome(outcome.error());
+}
+
+void ComputeNestClient::listServiceInstancesAsync(const ListServiceInstancesRequest& request, const ListServiceInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listServiceInstances(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestClient::ListServiceInstancesOutcomeCallable ComputeNestClient::listServiceInstancesCallable(const ListServiceInstancesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListServiceInstancesOutcome()>>(
+			[this, request]()
+			{
+			return this->listServiceInstances(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

computenest/src/model/ContinueDeployServiceInstanceRequest.cc

@@ -0,0 +1,80 @@
+/*
+ * 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/computenest/model/ContinueDeployServiceInstanceRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::ContinueDeployServiceInstanceRequest;
+
+ContinueDeployServiceInstanceRequest::ContinueDeployServiceInstanceRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "ContinueDeployServiceInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ContinueDeployServiceInstanceRequest::~ContinueDeployServiceInstanceRequest() {}
+
+std::string ContinueDeployServiceInstanceRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void ContinueDeployServiceInstanceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string ContinueDeployServiceInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ContinueDeployServiceInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ContinueDeployServiceInstanceRequest::getServiceInstanceId() const {
+  return serviceInstanceId_;
+}
+
+void ContinueDeployServiceInstanceRequest::setServiceInstanceId(const std::string &serviceInstanceId) {
+  serviceInstanceId_ = serviceInstanceId;
+  setParameter(std::string("ServiceInstanceId"), serviceInstanceId);
+}
+
+bool ContinueDeployServiceInstanceRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ContinueDeployServiceInstanceRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string ContinueDeployServiceInstanceRequest::getParameters() const {
+  return parameters_;
+}
+
+void ContinueDeployServiceInstanceRequest::setParameters(const std::string &parameters) {
+  parameters_ = parameters;
+  setParameter(std::string("Parameters"), parameters);
+}
+
+std::vector<std::string> ContinueDeployServiceInstanceRequest::getOption() const {
+  return option_;
+}
+
+void ContinueDeployServiceInstanceRequest::setOption(const std::vector<std::string> &option) {
+  option_ = option;
+}
+

computenest/src/model/ContinueDeployServiceInstanceResult.cc

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenest/model/ContinueDeployServiceInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+ContinueDeployServiceInstanceResult::ContinueDeployServiceInstanceResult() :
+	ServiceResult()
+{}
+
+ContinueDeployServiceInstanceResult::ContinueDeployServiceInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ContinueDeployServiceInstanceResult::~ContinueDeployServiceInstanceResult()
+{}
+
+void ContinueDeployServiceInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dryRunResultNode = value["DryRunResult"];
+		auto allParametersNotAllowedToBeModified = dryRunResultNode["ParametersNotAllowedToBeModified"]["parameterNotAllowedToBeModified"];
+		for (auto value : allParametersNotAllowedToBeModified)
+			dryRunResult_.parametersNotAllowedToBeModified.push_back(value.asString());
+		auto allParametersConditionallyAllowedToBeModified = dryRunResultNode["ParametersConditionallyAllowedToBeModified"]["parameterConditionallyAllowedToBeModified"];
+		for (auto value : allParametersConditionallyAllowedToBeModified)
+			dryRunResult_.parametersConditionallyAllowedToBeModified.push_back(value.asString());
+		auto allParametersAllowedToBeModified = dryRunResultNode["ParametersAllowedToBeModified"]["parameterAllowedToBeModified"];
+		for (auto value : allParametersAllowedToBeModified)
+			dryRunResult_.parametersAllowedToBeModified.push_back(value.asString());
+	if(!value["ServiceInstanceId"].isNull())
+		serviceInstanceId_ = value["ServiceInstanceId"].asString();
+
+}
+
+std::string ContinueDeployServiceInstanceResult::getServiceInstanceId()const
+{
+	return serviceInstanceId_;
+}
+
+ContinueDeployServiceInstanceResult::DryRunResult ContinueDeployServiceInstanceResult::getDryRunResult()const
+{
+	return dryRunResult_;
+}
+

computenest/src/model/CreateServiceInstanceRequest.cc

@@ -0,0 +1,208 @@
+/*
+ * 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/computenest/model/CreateServiceInstanceRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::CreateServiceInstanceRequest;
+
+CreateServiceInstanceRequest::CreateServiceInstanceRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "CreateServiceInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateServiceInstanceRequest::~CreateServiceInstanceRequest() {}
+
+CreateServiceInstanceRequest::Commodity CreateServiceInstanceRequest::getCommodity() const {
+  return commodity_;
+}
+
+void CreateServiceInstanceRequest::setCommodity(const CreateServiceInstanceRequest::Commodity &commodity) {
+  commodity_ = commodity;
+  setParameter(std::string("Commodity") + ".PayPeriod", std::to_string(commodity.payPeriod));
+  setParameter(std::string("Commodity") + ".PayPeriodUnit", commodity.payPeriodUnit);
+}
+
+std::string CreateServiceInstanceRequest::getContactGroup() const {
+  return contactGroup_;
+}
+
+void CreateServiceInstanceRequest::setContactGroup(const std::string &contactGroup) {
+  contactGroup_ = contactGroup;
+  setParameter(std::string("ContactGroup"), contactGroup);
+}
+
+std::string CreateServiceInstanceRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateServiceInstanceRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateServiceInstanceRequest::getSpecificationCode() const {
+  return specificationCode_;
+}
+
+void CreateServiceInstanceRequest::setSpecificationCode(const std::string &specificationCode) {
+  specificationCode_ = specificationCode;
+  setParameter(std::string("SpecificationCode"), specificationCode);
+}
+
+std::string CreateServiceInstanceRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateServiceInstanceRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateServiceInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateServiceInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+bool CreateServiceInstanceRequest::getEnableInstanceOps() const {
+  return enableInstanceOps_;
+}
+
+void CreateServiceInstanceRequest::setEnableInstanceOps(bool enableInstanceOps) {
+  enableInstanceOps_ = enableInstanceOps;
+  setParameter(std::string("EnableInstanceOps"), enableInstanceOps ? "true" : "false");
+}
+
+std::string CreateServiceInstanceRequest::getTemplateName() const {
+  return templateName_;
+}
+
+void CreateServiceInstanceRequest::setTemplateName(const std::string &templateName) {
+  templateName_ = templateName;
+  setParameter(std::string("TemplateName"), templateName);
+}
+
+std::vector<CreateServiceInstanceRequest::Tag> CreateServiceInstanceRequest::getTag() const {
+  return tag_;
+}
+
+void CreateServiceInstanceRequest::setTag(const std::vector<CreateServiceInstanceRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+bool CreateServiceInstanceRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateServiceInstanceRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+bool CreateServiceInstanceRequest::getEnableUserPrometheus() const {
+  return enableUserPrometheus_;
+}
+
+void CreateServiceInstanceRequest::setEnableUserPrometheus(bool enableUserPrometheus) {
+  enableUserPrometheus_ = enableUserPrometheus;
+  setParameter(std::string("EnableUserPrometheus"), enableUserPrometheus ? "true" : "false");
+}
+
+std::string CreateServiceInstanceRequest::getSpecificationName() const {
+  return specificationName_;
+}
+
+void CreateServiceInstanceRequest::setSpecificationName(const std::string &specificationName) {
+  specificationName_ = specificationName;
+  setParameter(std::string("SpecificationName"), specificationName);
+}
+
+std::string CreateServiceInstanceRequest::getTrialType() const {
+  return trialType_;
+}
+
+void CreateServiceInstanceRequest::setTrialType(const std::string &trialType) {
+  trialType_ = trialType;
+  setParameter(std::string("TrialType"), trialType);
+}
+
+std::string CreateServiceInstanceRequest::getName() const {
+  return name_;
+}
+
+void CreateServiceInstanceRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateServiceInstanceRequest::getServiceVersion() const {
+  return serviceVersion_;
+}
+
+void CreateServiceInstanceRequest::setServiceVersion(const std::string &serviceVersion) {
+  serviceVersion_ = serviceVersion;
+  setParameter(std::string("ServiceVersion"), serviceVersion);
+}
+
+std::string CreateServiceInstanceRequest::getServiceId() const {
+  return serviceId_;
+}
+
+void CreateServiceInstanceRequest::setServiceId(const std::string &serviceId) {
+  serviceId_ = serviceId;
+  setParameter(std::string("ServiceId"), serviceId);
+}
+
+std::string CreateServiceInstanceRequest::getParameters() const {
+  return parameters_;
+}
+
+void CreateServiceInstanceRequest::setParameters(const std::string &parameters) {
+  parameters_ = parameters;
+  setParameter(std::string("Parameters"), parameters);
+}
+
+long CreateServiceInstanceRequest::getPayType() const {
+  return payType_;
+}
+
+void CreateServiceInstanceRequest::setPayType(long payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), std::to_string(payType));
+}
+
+CreateServiceInstanceRequest::OperationMetadata CreateServiceInstanceRequest::getOperationMetadata() const {
+  return operationMetadata_;
+}
+
+void CreateServiceInstanceRequest::setOperationMetadata(const CreateServiceInstanceRequest::OperationMetadata &operationMetadata) {
+  operationMetadata_ = operationMetadata;
+  setParameter(std::string("OperationMetadata") + ".EndTime", operationMetadata.endTime);
+  setParameter(std::string("OperationMetadata") + ".Resources", operationMetadata.resources);
+  setParameter(std::string("OperationMetadata") + ".StartTime", operationMetadata.startTime);
+  setParameter(std::string("OperationMetadata") + ".ExtraInfo", operationMetadata.extraInfo);
+  setParameter(std::string("OperationMetadata") + ".ServiceInstanceId", operationMetadata.serviceInstanceId);
+}
+

computenest/src/model/CreateServiceInstanceResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/computenest/model/CreateServiceInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+CreateServiceInstanceResult::CreateServiceInstanceResult() :
+	ServiceResult()
+{}
+
+CreateServiceInstanceResult::CreateServiceInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateServiceInstanceResult::~CreateServiceInstanceResult()
+{}
+
+void CreateServiceInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["ServiceInstanceId"].isNull())
+		serviceInstanceId_ = value["ServiceInstanceId"].asString();
+	if(!value["MarketInstanceId"].isNull())
+		marketInstanceId_ = value["MarketInstanceId"].asString();
+
+}
+
+std::string CreateServiceInstanceResult::getStatus()const
+{
+	return status_;
+}
+
+std::string CreateServiceInstanceResult::getServiceInstanceId()const
+{
+	return serviceInstanceId_;
+}
+
+std::string CreateServiceInstanceResult::getMarketInstanceId()const
+{
+	return marketInstanceId_;
+}
+

computenest/src/model/DeleteServiceInstancesRequest.cc

@@ -0,0 +1,53 @@
+/*
+ * 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/computenest/model/DeleteServiceInstancesRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::DeleteServiceInstancesRequest;
+
+DeleteServiceInstancesRequest::DeleteServiceInstancesRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "DeleteServiceInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteServiceInstancesRequest::~DeleteServiceInstancesRequest() {}
+
+std::string DeleteServiceInstancesRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void DeleteServiceInstancesRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string DeleteServiceInstancesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteServiceInstancesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> DeleteServiceInstancesRequest::getServiceInstanceId() const {
+  return serviceInstanceId_;
+}
+
+void DeleteServiceInstancesRequest::setServiceInstanceId(const std::vector<std::string> &serviceInstanceId) {
+  serviceInstanceId_ = serviceInstanceId;
+}
+

computenest/src/model/DeleteServiceInstancesResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/computenest/model/DeleteServiceInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+DeleteServiceInstancesResult::DeleteServiceInstancesResult() :
+	ServiceResult()
+{}
+
+DeleteServiceInstancesResult::DeleteServiceInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteServiceInstancesResult::~DeleteServiceInstancesResult()
+{}
+
+void DeleteServiceInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

computenest/src/model/GetServiceInstanceRequest.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/computenest/model/GetServiceInstanceRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::GetServiceInstanceRequest;
+
+GetServiceInstanceRequest::GetServiceInstanceRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "GetServiceInstance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetServiceInstanceRequest::~GetServiceInstanceRequest() {}
+
+std::string GetServiceInstanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetServiceInstanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetServiceInstanceRequest::getServiceInstanceId() const {
+  return serviceInstanceId_;
+}
+
+void GetServiceInstanceRequest::setServiceInstanceId(const std::string &serviceInstanceId) {
+  serviceInstanceId_ = serviceInstanceId;
+  setParameter(std::string("ServiceInstanceId"), serviceInstanceId);
+}
+
+std::string GetServiceInstanceRequest::getMarketInstanceId() const {
+  return marketInstanceId_;
+}
+
+void GetServiceInstanceRequest::setMarketInstanceId(const std::string &marketInstanceId) {
+  marketInstanceId_ = marketInstanceId;
+  setParameter(std::string("MarketInstanceId"), marketInstanceId);
+}
+

computenest/src/model/GetServiceInstanceResult.cc

@@ -0,0 +1,363 @@
+/*
+ * 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/computenest/model/GetServiceInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+GetServiceInstanceResult::GetServiceInstanceResult() :
+	ServiceResult()
+{}
+
+GetServiceInstanceResult::GetServiceInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetServiceInstanceResult::~GetServiceInstanceResult()
+{}
+
+void GetServiceInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["Key"].isNull())
+			tagsObject.key = valueTagsTag["Key"].asString();
+		if(!valueTagsTag["Value"].isNull())
+			tagsObject.value = valueTagsTag["Value"].asString();
+		tags_.push_back(tagsObject);
+	}
+	auto serviceNode = value["Service"];
+	if(!serviceNode["Status"].isNull())
+		service_.status = serviceNode["Status"].asString();
+	if(!serviceNode["PublishTime"].isNull())
+		service_.publishTime = serviceNode["PublishTime"].asString();
+	if(!serviceNode["Version"].isNull())
+		service_.version = serviceNode["Version"].asString();
+	if(!serviceNode["DeployMetadata"].isNull())
+		service_.deployMetadata = serviceNode["DeployMetadata"].asString();
+	if(!serviceNode["DeployType"].isNull())
+		service_.deployType = serviceNode["DeployType"].asString();
+	if(!serviceNode["ServiceId"].isNull())
+		service_.serviceId = serviceNode["ServiceId"].asString();
+	if(!serviceNode["SupplierUrl"].isNull())
+		service_.supplierUrl = serviceNode["SupplierUrl"].asString();
+	if(!serviceNode["ServiceType"].isNull())
+		service_.serviceType = serviceNode["ServiceType"].asString();
+	if(!serviceNode["SupplierName"].isNull())
+		service_.supplierName = serviceNode["SupplierName"].asString();
+	if(!serviceNode["VersionName"].isNull())
+		service_.versionName = serviceNode["VersionName"].asString();
+	if(!serviceNode["UpgradeMetadata"].isNull())
+		service_.upgradeMetadata = serviceNode["UpgradeMetadata"].asString();
+	if(!serviceNode["ServiceProductUrl"].isNull())
+		service_.serviceProductUrl = serviceNode["ServiceProductUrl"].asString();
+	if(!serviceNode["ServiceDocUrl"].isNull())
+		service_.serviceDocUrl = serviceNode["ServiceDocUrl"].asString();
+	auto allServiceInfosNode = serviceNode["ServiceInfos"]["ServiceInfo"];
+	for (auto serviceNodeServiceInfosServiceInfo : allServiceInfosNode)
+	{
+		Service::ServiceInfo serviceInfoObject;
+		if(!serviceNodeServiceInfosServiceInfo["Locale"].isNull())
+			serviceInfoObject.locale = serviceNodeServiceInfosServiceInfo["Locale"].asString();
+		if(!serviceNodeServiceInfosServiceInfo["Image"].isNull())
+			serviceInfoObject.image = serviceNodeServiceInfosServiceInfo["Image"].asString();
+		if(!serviceNodeServiceInfosServiceInfo["Name"].isNull())
+			serviceInfoObject.name = serviceNodeServiceInfosServiceInfo["Name"].asString();
+		if(!serviceNodeServiceInfosServiceInfo["ShortDescription"].isNull())
+			serviceInfoObject.shortDescription = serviceNodeServiceInfosServiceInfo["ShortDescription"].asString();
+		service_.serviceInfos.push_back(serviceInfoObject);
+	}
+		auto allUpgradableServiceVersions = serviceNode["UpgradableServiceVersions"]["UpgradableServiceVersion"];
+		for (auto value : allUpgradableServiceVersions)
+			service_.upgradableServiceVersions.push_back(value.asString());
+	auto networkConfigNode = value["NetworkConfig"];
+	if(!networkConfigNode["EndpointId"].isNull())
+		networkConfig_.endpointId = networkConfigNode["EndpointId"].asString();
+	if(!networkConfigNode["PrivateZoneId"].isNull())
+		networkConfig_.privateZoneId = networkConfigNode["PrivateZoneId"].asString();
+	auto allPrivateVpcConnectionsNode = networkConfigNode["PrivateVpcConnections"]["PrivateVpcConnection"];
+	for (auto networkConfigNodePrivateVpcConnectionsPrivateVpcConnection : allPrivateVpcConnectionsNode)
+	{
+		NetworkConfig::PrivateVpcConnection privateVpcConnectionObject;
+		if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].isNull())
+			privateVpcConnectionObject.endpointId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].asString();
+		if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneId"].isNull())
+			privateVpcConnectionObject.privateZoneId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneId"].asString();
+		if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneName"].isNull())
+			privateVpcConnectionObject.privateZoneName = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["PrivateZoneName"].asString();
+		if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["RegionId"].isNull())
+			privateVpcConnectionObject.regionId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["RegionId"].asString();
+		auto allConnectionConfigsNode = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["ConnectionConfigs"]["ConnectionConfig"];
+		for (auto networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig : allConnectionConfigsNode)
+		{
+			NetworkConfig::PrivateVpcConnection::ConnectionConfig connectionConfigsObject;
+			if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["VpcId"].isNull())
+				connectionConfigsObject.vpcId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["VpcId"].asString();
+			if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["IngressEndpointStatus"].isNull())
+				connectionConfigsObject.ingressEndpointStatus = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["IngressEndpointStatus"].asString();
+			if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["NetworkServiceStatus"].isNull())
+				connectionConfigsObject.networkServiceStatus = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["NetworkServiceStatus"].asString();
+			if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["DomainName"].isNull())
+				connectionConfigsObject.domainName = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["DomainName"].asString();
+			if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["RegionId"].isNull())
+				connectionConfigsObject.regionId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["RegionId"].asString();
+			if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["ConnectBandwidth"].isNull())
+				connectionConfigsObject.connectBandwidth = std::stoi(networkConfigNodePrivateVpcConnectionsPrivateVpcConnectionConnectionConfigsConnectionConfig["ConnectBandwidth"].asString());
+			auto allSecurityGroups = value["SecurityGroups"]["SecurityGroup"];
+			for (auto value : allSecurityGroups)
+				connectionConfigsObject.securityGroups.push_back(value.asString());
+			auto allVSwitches = value["VSwitches"]["VSwitch"];
+			for (auto value : allVSwitches)
+				connectionConfigsObject.vSwitches.push_back(value.asString());
+			auto allEndpointIps = value["EndpointIps"]["EndpointIp"];
+			for (auto value : allEndpointIps)
+				connectionConfigsObject.endpointIps.push_back(value.asString());
+			privateVpcConnectionObject.connectionConfigs.push_back(connectionConfigsObject);
+		}
+		networkConfig_.privateVpcConnections.push_back(privateVpcConnectionObject);
+	}
+	auto allReversePrivateVpcConnectionsNode = networkConfigNode["ReversePrivateVpcConnections"]["ReversePrivateVpcConnection"];
+	for (auto networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection : allReversePrivateVpcConnectionsNode)
+	{
+		NetworkConfig::ReversePrivateVpcConnection reversePrivateVpcConnectionObject;
+		if(!networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointId"].isNull())
+			reversePrivateVpcConnectionObject.endpointId = networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointId"].asString();
+		networkConfig_.reversePrivateVpcConnections.push_back(reversePrivateVpcConnectionObject);
+	}
+	if(!value["Outputs"].isNull())
+		outputs_ = value["Outputs"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["TemplateName"].isNull())
+		templateName_ = value["TemplateName"].asString();
+	if(!value["UpdateTime"].isNull())
+		updateTime_ = value["UpdateTime"].asString();
+	if(!value["Progress"].isNull())
+		progress_ = std::stol(value["Progress"].asString());
+	if(!value["Parameters"].isNull())
+		parameters_ = value["Parameters"].asString();
+	if(!value["ServiceInstanceId"].isNull())
+		serviceInstanceId_ = value["ServiceInstanceId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["StatusDetail"].isNull())
+		statusDetail_ = value["StatusDetail"].asString();
+	if(!value["Resources"].isNull())
+		resources_ = value["Resources"].asString();
+	if(!value["OperationStartTime"].isNull())
+		operationStartTime_ = value["OperationStartTime"].asString();
+	if(!value["OperationEndTime"].isNull())
+		operationEndTime_ = value["OperationEndTime"].asString();
+	if(!value["OperatedServiceInstanceId"].isNull())
+		operatedServiceInstanceId_ = value["OperatedServiceInstanceId"].asString();
+	if(!value["EnableInstanceOps"].isNull())
+		enableInstanceOps_ = value["EnableInstanceOps"].asString() == "true";
+	if(!value["IsOperated"].isNull())
+		isOperated_ = value["IsOperated"].asString() == "true";
+	if(!value["LicenseEndTime"].isNull())
+		licenseEndTime_ = value["LicenseEndTime"].asString();
+	if(!value["UserId"].isNull())
+		userId_ = std::stol(value["UserId"].asString());
+	if(!value["SupplierUid"].isNull())
+		supplierUid_ = std::stol(value["SupplierUid"].asString());
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["Source"].isNull())
+		source_ = value["Source"].asString();
+	if(!value["ServiceType"].isNull())
+		serviceType_ = value["ServiceType"].asString();
+	if(!value["PayType"].isNull())
+		payType_ = value["PayType"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["EnableUserPrometheus"].isNull())
+		enableUserPrometheus_ = value["EnableUserPrometheus"].asString() == "true";
+	if(!value["Components"].isNull())
+		components_ = value["Components"].asString();
+	if(!value["PredefinedParameterName"].isNull())
+		predefinedParameterName_ = value["PredefinedParameterName"].asString();
+	if(!value["MarketInstanceId"].isNull())
+		marketInstanceId_ = value["MarketInstanceId"].asString();
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+
+}
+
+std::string GetServiceInstanceResult::getOperatedServiceInstanceId()const
+{
+	return operatedServiceInstanceId_;
+}
+
+std::string GetServiceInstanceResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string GetServiceInstanceResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string GetServiceInstanceResult::getOperationEndTime()const
+{
+	return operationEndTime_;
+}
+
+bool GetServiceInstanceResult::getEnableInstanceOps()const
+{
+	return enableInstanceOps_;
+}
+
+std::string GetServiceInstanceResult::getPredefinedParameterName()const
+{
+	return predefinedParameterName_;
+}
+
+std::string GetServiceInstanceResult::getSource()const
+{
+	return source_;
+}
+
+std::string GetServiceInstanceResult::getName()const
+{
+	return name_;
+}
+
+std::string GetServiceInstanceResult::getComponents()const
+{
+	return components_;
+}
+
+std::string GetServiceInstanceResult::getOperationStartTime()const
+{
+	return operationStartTime_;
+}
+
+std::string GetServiceInstanceResult::getServiceInstanceId()const
+{
+	return serviceInstanceId_;
+}
+
+std::string GetServiceInstanceResult::getServiceType()const
+{
+	return serviceType_;
+}
+
+std::string GetServiceInstanceResult::getTemplateName()const
+{
+	return templateName_;
+}
+
+std::string GetServiceInstanceResult::getMarketInstanceId()const
+{
+	return marketInstanceId_;
+}
+
+std::vector<GetServiceInstanceResult::Tag> GetServiceInstanceResult::getTags()const
+{
+	return tags_;
+}
+
+std::string GetServiceInstanceResult::getStatus()const
+{
+	return status_;
+}
+
+long GetServiceInstanceResult::getProgress()const
+{
+	return progress_;
+}
+
+std::string GetServiceInstanceResult::getParameters()const
+{
+	return parameters_;
+}
+
+std::string GetServiceInstanceResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+GetServiceInstanceResult::NetworkConfig GetServiceInstanceResult::getNetworkConfig()const
+{
+	return networkConfig_;
+}
+
+GetServiceInstanceResult::Service GetServiceInstanceResult::getService()const
+{
+	return service_;
+}
+
+std::string GetServiceInstanceResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string GetServiceInstanceResult::getLicenseEndTime()const
+{
+	return licenseEndTime_;
+}
+
+long GetServiceInstanceResult::getUserId()const
+{
+	return userId_;
+}
+
+bool GetServiceInstanceResult::getEnableUserPrometheus()const
+{
+	return enableUserPrometheus_;
+}
+
+std::string GetServiceInstanceResult::getStatusDetail()const
+{
+	return statusDetail_;
+}
+
+std::string GetServiceInstanceResult::getOutputs()const
+{
+	return outputs_;
+}
+
+std::string GetServiceInstanceResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+bool GetServiceInstanceResult::getIsOperated()const
+{
+	return isOperated_;
+}
+
+long GetServiceInstanceResult::getSupplierUid()const
+{
+	return supplierUid_;
+}
+
+std::string GetServiceInstanceResult::getResources()const
+{
+	return resources_;
+}
+

computenest/src/model/ListServiceInstanceLogsRequest.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/computenest/model/ListServiceInstanceLogsRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::ListServiceInstanceLogsRequest;
+
+ListServiceInstanceLogsRequest::ListServiceInstanceLogsRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "ListServiceInstanceLogs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListServiceInstanceLogsRequest::~ListServiceInstanceLogsRequest() {}
+
+std::string ListServiceInstanceLogsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListServiceInstanceLogsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListServiceInstanceLogsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListServiceInstanceLogsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListServiceInstanceLogsRequest::getServiceInstanceId() const {
+  return serviceInstanceId_;
+}
+
+void ListServiceInstanceLogsRequest::setServiceInstanceId(const std::string &serviceInstanceId) {
+  serviceInstanceId_ = serviceInstanceId;
+  setParameter(std::string("ServiceInstanceId"), serviceInstanceId);
+}
+
+std::string ListServiceInstanceLogsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListServiceInstanceLogsRequest::setMaxResults(const std::string &maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), maxResults);
+}
+

computenest/src/model/ListServiceInstanceLogsResult.cc

@@ -0,0 +1,85 @@
+/*
+ * 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/computenest/model/ListServiceInstanceLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+ListServiceInstanceLogsResult::ListServiceInstanceLogsResult() :
+	ServiceResult()
+{}
+
+ListServiceInstanceLogsResult::ListServiceInstanceLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListServiceInstanceLogsResult::~ListServiceInstanceLogsResult()
+{}
+
+void ListServiceInstanceLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allServiceInstancesLogsNode = value["ServiceInstancesLogs"]["ServiceInstanceLogs"];
+	for (auto valueServiceInstancesLogsServiceInstanceLogs : allServiceInstancesLogsNode)
+	{
+		ServiceInstanceLogs serviceInstancesLogsObject;
+		if(!valueServiceInstancesLogsServiceInstanceLogs["Timestamp"].isNull())
+			serviceInstancesLogsObject.timestamp = valueServiceInstancesLogsServiceInstanceLogs["Timestamp"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["ServiceInstanceId"].isNull())
+			serviceInstancesLogsObject.serviceInstanceId = valueServiceInstancesLogsServiceInstanceLogs["ServiceInstanceId"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["Source"].isNull())
+			serviceInstancesLogsObject.source = valueServiceInstancesLogsServiceInstanceLogs["Source"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["Content"].isNull())
+			serviceInstancesLogsObject.content = valueServiceInstancesLogsServiceInstanceLogs["Content"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["LogType"].isNull())
+			serviceInstancesLogsObject.logType = valueServiceInstancesLogsServiceInstanceLogs["LogType"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["ResourceType"].isNull())
+			serviceInstancesLogsObject.resourceType = valueServiceInstancesLogsServiceInstanceLogs["ResourceType"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["ResourceId"].isNull())
+			serviceInstancesLogsObject.resourceId = valueServiceInstancesLogsServiceInstanceLogs["ResourceId"].asString();
+		if(!valueServiceInstancesLogsServiceInstanceLogs["Status"].isNull())
+			serviceInstancesLogsObject.status = valueServiceInstancesLogsServiceInstanceLogs["Status"].asString();
+		serviceInstancesLogs_.push_back(serviceInstancesLogsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+
+}
+
+std::string ListServiceInstanceLogsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListServiceInstanceLogsResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<ListServiceInstanceLogsResult::ServiceInstanceLogs> ListServiceInstanceLogsResult::getServiceInstancesLogs()const
+{
+	return serviceInstancesLogs_;
+}
+

computenest/src/model/ListServiceInstanceResourcesRequest.cc

@@ -0,0 +1,112 @@
+/*
+ * 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/computenest/model/ListServiceInstanceResourcesRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::ListServiceInstanceResourcesRequest;
+
+ListServiceInstanceResourcesRequest::ListServiceInstanceResourcesRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "ListServiceInstanceResources") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListServiceInstanceResourcesRequest::~ListServiceInstanceResourcesRequest() {}
+
+std::string ListServiceInstanceResourcesRequest::getExpireTimeEnd() const {
+  return expireTimeEnd_;
+}
+
+void ListServiceInstanceResourcesRequest::setExpireTimeEnd(const std::string &expireTimeEnd) {
+  expireTimeEnd_ = expireTimeEnd;
+  setParameter(std::string("ExpireTimeEnd"), expireTimeEnd);
+}
+
+std::string ListServiceInstanceResourcesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListServiceInstanceResourcesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListServiceInstanceResourcesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListServiceInstanceResourcesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<std::string> ListServiceInstanceResourcesRequest::getResourceARN() const {
+  return resourceARN_;
+}
+
+void ListServiceInstanceResourcesRequest::setResourceARN(const std::vector<std::string> &resourceARN) {
+  resourceARN_ = resourceARN;
+}
+
+std::vector<ListServiceInstanceResourcesRequest::Tag> ListServiceInstanceResourcesRequest::getTag() const {
+  return tag_;
+}
+
+void ListServiceInstanceResourcesRequest::setTag(const std::vector<ListServiceInstanceResourcesRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::string ListServiceInstanceResourcesRequest::getServiceInstanceId() const {
+  return serviceInstanceId_;
+}
+
+void ListServiceInstanceResourcesRequest::setServiceInstanceId(const std::string &serviceInstanceId) {
+  serviceInstanceId_ = serviceInstanceId;
+  setParameter(std::string("ServiceInstanceId"), serviceInstanceId);
+}
+
+std::string ListServiceInstanceResourcesRequest::getExpireTimeStart() const {
+  return expireTimeStart_;
+}
+
+void ListServiceInstanceResourcesRequest::setExpireTimeStart(const std::string &expireTimeStart) {
+  expireTimeStart_ = expireTimeStart;
+  setParameter(std::string("ExpireTimeStart"), expireTimeStart);
+}
+
+std::string ListServiceInstanceResourcesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListServiceInstanceResourcesRequest::setMaxResults(const std::string &maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), maxResults);
+}
+
+std::string ListServiceInstanceResourcesRequest::getPayType() const {
+  return payType_;
+}
+
+void ListServiceInstanceResourcesRequest::setPayType(const std::string &payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), payType);
+}
+

computenest/src/model/ListServiceInstanceResourcesResult.cc

@@ -0,0 +1,87 @@
+/*
+ * 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/computenest/model/ListServiceInstanceResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+ListServiceInstanceResourcesResult::ListServiceInstanceResourcesResult() :
+	ServiceResult()
+{}
+
+ListServiceInstanceResourcesResult::ListServiceInstanceResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListServiceInstanceResourcesResult::~ListServiceInstanceResourcesResult()
+{}
+
+void ListServiceInstanceResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResourcesNode = value["Resources"]["ResourcesItem"];
+	for (auto valueResourcesResourcesItem : allResourcesNode)
+	{
+		ResourcesItem resourcesObject;
+		if(!valueResourcesResourcesItem["ResourceARN"].isNull())
+			resourcesObject.resourceARN = valueResourcesResourcesItem["ResourceARN"].asString();
+		if(!valueResourcesResourcesItem["PayType"].isNull())
+			resourcesObject.payType = valueResourcesResourcesItem["PayType"].asString();
+		if(!valueResourcesResourcesItem["RenewStatus"].isNull())
+			resourcesObject.renewStatus = valueResourcesResourcesItem["RenewStatus"].asString();
+		if(!valueResourcesResourcesItem["CreateTime"].isNull())
+			resourcesObject.createTime = valueResourcesResourcesItem["CreateTime"].asString();
+		if(!valueResourcesResourcesItem["ExpireTime"].isNull())
+			resourcesObject.expireTime = valueResourcesResourcesItem["ExpireTime"].asString();
+		if(!valueResourcesResourcesItem["RenewalPeriod"].isNull())
+			resourcesObject.renewalPeriod = std::stoi(valueResourcesResourcesItem["RenewalPeriod"].asString());
+		if(!valueResourcesResourcesItem["RenewalPeriodUnit"].isNull())
+			resourcesObject.renewalPeriodUnit = valueResourcesResourcesItem["RenewalPeriodUnit"].asString();
+		if(!valueResourcesResourcesItem["ProductType"].isNull())
+			resourcesObject.productType = valueResourcesResourcesItem["ProductType"].asString();
+		if(!valueResourcesResourcesItem["ProductCode"].isNull())
+			resourcesObject.productCode = valueResourcesResourcesItem["ProductCode"].asString();
+		resources_.push_back(resourcesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+
+}
+
+std::string ListServiceInstanceResourcesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListServiceInstanceResourcesResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<ListServiceInstanceResourcesResult::ResourcesItem> ListServiceInstanceResourcesResult::getResources()const
+{
+	return resources_;
+}
+

computenest/src/model/ListServiceInstancesRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenest/model/ListServiceInstancesRequest.h>
+
+using AlibabaCloud::ComputeNest::Model::ListServiceInstancesRequest;
+
+ListServiceInstancesRequest::ListServiceInstancesRequest()
+    : RpcServiceRequest("computenest", "2021-06-01", "ListServiceInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListServiceInstancesRequest::~ListServiceInstancesRequest() {}
+
+std::string ListServiceInstancesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void ListServiceInstancesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string ListServiceInstancesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListServiceInstancesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListServiceInstancesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListServiceInstancesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::vector<ListServiceInstancesRequest::Tag> ListServiceInstancesRequest::getTag() const {
+  return tag_;
+}
+
+void ListServiceInstancesRequest::setTag(const std::vector<ListServiceInstancesRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+std::vector<ListServiceInstancesRequest::Filter> ListServiceInstancesRequest::getFilter() const {
+  return filter_;
+}
+
+void ListServiceInstancesRequest::setFilter(const std::vector<ListServiceInstancesRequest::Filter> &filter) {
+  filter_ = filter;
+  for(int dep1 = 0; dep1 != filter.size(); dep1++) {
+  auto filterObj = filter.at(dep1);
+  std::string filterObjStr = std::string("Filter") + "." + std::to_string(dep1 + 1);
+    setParameter(filterObjStr + ".Name", filterObj.name);
+  }
+}
+
+std::string ListServiceInstancesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListServiceInstancesRequest::setMaxResults(const std::string &maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), maxResults);
+}
+

computenest/src/model/ListServiceInstancesResult.cc

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenest/model/ListServiceInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNest;
+using namespace AlibabaCloud::ComputeNest::Model;
+
+ListServiceInstancesResult::ListServiceInstancesResult() :
+	ServiceResult()
+{}
+
+ListServiceInstancesResult::ListServiceInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListServiceInstancesResult::~ListServiceInstancesResult()
+{}
+
+void ListServiceInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allServiceInstancesNode = value["ServiceInstances"]["ServiceInstance"];
+	for (auto valueServiceInstancesServiceInstance : allServiceInstancesNode)
+	{
+		ServiceInstance serviceInstancesObject;
+		if(!valueServiceInstancesServiceInstance["Name"].isNull())
+			serviceInstancesObject.name = valueServiceInstancesServiceInstance["Name"].asString();
+		if(!valueServiceInstancesServiceInstance["Status"].isNull())
+			serviceInstancesObject.status = valueServiceInstancesServiceInstance["Status"].asString();
+		if(!valueServiceInstancesServiceInstance["Outputs"].isNull())
+			serviceInstancesObject.outputs = valueServiceInstancesServiceInstance["Outputs"].asString();
+		if(!valueServiceInstancesServiceInstance["UpdateTime"].isNull())
+			serviceInstancesObject.updateTime = valueServiceInstancesServiceInstance["UpdateTime"].asString();
+		if(!valueServiceInstancesServiceInstance["Parameters"].isNull())
+			serviceInstancesObject.parameters = valueServiceInstancesServiceInstance["Parameters"].asString();
+		if(!valueServiceInstancesServiceInstance["ServiceInstanceId"].isNull())
+			serviceInstancesObject.serviceInstanceId = valueServiceInstancesServiceInstance["ServiceInstanceId"].asString();
+		if(!valueServiceInstancesServiceInstance["CreateTime"].isNull())
+			serviceInstancesObject.createTime = valueServiceInstancesServiceInstance["CreateTime"].asString();
+		if(!valueServiceInstancesServiceInstance["StatusDetail"].isNull())
+			serviceInstancesObject.statusDetail = valueServiceInstancesServiceInstance["StatusDetail"].asString();
+		if(!valueServiceInstancesServiceInstance["Progress"].isNull())
+			serviceInstancesObject.progress = std::stol(valueServiceInstancesServiceInstance["Progress"].asString());
+		if(!valueServiceInstancesServiceInstance["Resources"].isNull())
+			serviceInstancesObject.resources = valueServiceInstancesServiceInstance["Resources"].asString();
+		if(!valueServiceInstancesServiceInstance["TemplateName"].isNull())
+			serviceInstancesObject.templateName = valueServiceInstancesServiceInstance["TemplateName"].asString();
+		if(!valueServiceInstancesServiceInstance["OperatedServiceInstanceId"].isNull())
+			serviceInstancesObject.operatedServiceInstanceId = valueServiceInstancesServiceInstance["OperatedServiceInstanceId"].asString();
+		if(!valueServiceInstancesServiceInstance["OperationStartTime"].isNull())
+			serviceInstancesObject.operationStartTime = valueServiceInstancesServiceInstance["OperationStartTime"].asString();
+		if(!valueServiceInstancesServiceInstance["OperationEndTime"].isNull())
+			serviceInstancesObject.operationEndTime = valueServiceInstancesServiceInstance["OperationEndTime"].asString();
+		if(!valueServiceInstancesServiceInstance["EnableInstanceOps"].isNull())
+			serviceInstancesObject.enableInstanceOps = valueServiceInstancesServiceInstance["EnableInstanceOps"].asString() == "true";
+		if(!valueServiceInstancesServiceInstance["Source"].isNull())
+			serviceInstancesObject.source = valueServiceInstancesServiceInstance["Source"].asString();
+		if(!valueServiceInstancesServiceInstance["EndTime"].isNull())
+			serviceInstancesObject.endTime = valueServiceInstancesServiceInstance["EndTime"].asString();
+		if(!valueServiceInstancesServiceInstance["ServiceType"].isNull())
+			serviceInstancesObject.serviceType = valueServiceInstancesServiceInstance["ServiceType"].asString();
+		if(!valueServiceInstancesServiceInstance["PayType"].isNull())
+			serviceInstancesObject.payType = valueServiceInstancesServiceInstance["PayType"].asString();
+		if(!valueServiceInstancesServiceInstance["MarketInstanceId"].isNull())
+			serviceInstancesObject.marketInstanceId = valueServiceInstancesServiceInstance["MarketInstanceId"].asString();
+		if(!valueServiceInstancesServiceInstance["ResourceGroupId"].isNull())
+			serviceInstancesObject.resourceGroupId = valueServiceInstancesServiceInstance["ResourceGroupId"].asString();
+		auto allTagsNode = valueServiceInstancesServiceInstance["Tags"]["Tag"];
+		for (auto valueServiceInstancesServiceInstanceTagsTag : allTagsNode)
+		{
+			ServiceInstance::Tag tagsObject;
+			if(!valueServiceInstancesServiceInstanceTagsTag["Key"].isNull())
+				tagsObject.key = valueServiceInstancesServiceInstanceTagsTag["Key"].asString();
+			if(!valueServiceInstancesServiceInstanceTagsTag["Value"].isNull())
+				tagsObject.value = valueServiceInstancesServiceInstanceTagsTag["Value"].asString();
+			serviceInstancesObject.tags.push_back(tagsObject);
+		}
+		auto serviceNode = value["Service"];
+		if(!serviceNode["Status"].isNull())
+			serviceInstancesObject.service.status = serviceNode["Status"].asString();
+		if(!serviceNode["PublishTime"].isNull())
+			serviceInstancesObject.service.publishTime = serviceNode["PublishTime"].asString();
+		if(!serviceNode["Version"].isNull())
+			serviceInstancesObject.service.version = serviceNode["Version"].asString();
+		if(!serviceNode["DeployType"].isNull())
+			serviceInstancesObject.service.deployType = serviceNode["DeployType"].asString();
+		if(!serviceNode["ServiceId"].isNull())
+			serviceInstancesObject.service.serviceId = serviceNode["ServiceId"].asString();
+		if(!serviceNode["SupplierUrl"].isNull())
+			serviceInstancesObject.service.supplierUrl = serviceNode["SupplierUrl"].asString();
+		if(!serviceNode["ServiceType"].isNull())
+			serviceInstancesObject.service.serviceType = serviceNode["ServiceType"].asString();
+		if(!serviceNode["SupplierName"].isNull())
+			serviceInstancesObject.service.supplierName = serviceNode["SupplierName"].asString();
+		if(!serviceNode["VersionName"].isNull())
+			serviceInstancesObject.service.versionName = serviceNode["VersionName"].asString();
+		auto allServiceInfosNode = serviceNode["ServiceInfos"]["ServiceInfo"];
+		for (auto serviceNodeServiceInfosServiceInfo : allServiceInfosNode)
+		{
+			ServiceInstance::Service::ServiceInfo serviceInfoObject;
+			if(!serviceNodeServiceInfosServiceInfo["Locale"].isNull())
+				serviceInfoObject.locale = serviceNodeServiceInfosServiceInfo["Locale"].asString();
+			if(!serviceNodeServiceInfosServiceInfo["Image"].isNull())
+				serviceInfoObject.image = serviceNodeServiceInfosServiceInfo["Image"].asString();
+			if(!serviceNodeServiceInfosServiceInfo["Name"].isNull())
+				serviceInfoObject.name = serviceNodeServiceInfosServiceInfo["Name"].asString();
+			if(!serviceNodeServiceInfosServiceInfo["ShortDescription"].isNull())
+				serviceInfoObject.shortDescription = serviceNodeServiceInfosServiceInfo["ShortDescription"].asString();
+			serviceInstancesObject.service.serviceInfos.push_back(serviceInfoObject);
+		}
+		serviceInstances_.push_back(serviceInstancesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+
+}
+
+long ListServiceInstancesResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<ListServiceInstancesResult::ServiceInstance> ListServiceInstancesResult::getServiceInstances()const
+{
+	return serviceInstances_;
+}
+
+std::string ListServiceInstancesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListServiceInstancesResult::getMaxResults()const
+{
+	return maxResults_;
+}
+