Public ListServiceInstances and GetServiceInstance OpenApi.

VERSION

@@ -1 +1 @@
-1.36.1409
+1.36.1410

computenestsupplier/CMakeLists.txt

@@ -0,0 +1,122 @@
+#
+# 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(computenestsupplier_public_header 
+	include/alibabacloud/computenestsupplier/ComputeNestSupplierClient.h
+	include/alibabacloud/computenestsupplier/ComputeNestSupplierExport.h )
+
+set(computenestsupplier_public_header_model 
+	include/alibabacloud/computenestsupplier/model/CreateArtifactRequest.h
+	include/alibabacloud/computenestsupplier/model/CreateArtifactResult.h
+	include/alibabacloud/computenestsupplier/model/DeleteArtifactRequest.h
+	include/alibabacloud/computenestsupplier/model/DeleteArtifactResult.h
+	include/alibabacloud/computenestsupplier/model/GetArtifactRequest.h
+	include/alibabacloud/computenestsupplier/model/GetArtifactResult.h
+	include/alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsRequest.h
+	include/alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsResult.h
+	include/alibabacloud/computenestsupplier/model/GetServiceInstanceRequest.h
+	include/alibabacloud/computenestsupplier/model/GetServiceInstanceResult.h
+	include/alibabacloud/computenestsupplier/model/ListArtifactVersionsRequest.h
+	include/alibabacloud/computenestsupplier/model/ListArtifactVersionsResult.h
+	include/alibabacloud/computenestsupplier/model/ListArtifactsRequest.h
+	include/alibabacloud/computenestsupplier/model/ListArtifactsResult.h
+	include/alibabacloud/computenestsupplier/model/ListServiceInstancesRequest.h
+	include/alibabacloud/computenestsupplier/model/ListServiceInstancesResult.h
+	include/alibabacloud/computenestsupplier/model/ReleaseArtifactRequest.h
+	include/alibabacloud/computenestsupplier/model/ReleaseArtifactResult.h
+	include/alibabacloud/computenestsupplier/model/UpdateArtifactRequest.h
+	include/alibabacloud/computenestsupplier/model/UpdateArtifactResult.h )
+
+set(computenestsupplier_src 
+	src/ComputeNestSupplierClient.cc
+	src/model/CreateArtifactRequest.cc
+	src/model/CreateArtifactResult.cc
+	src/model/DeleteArtifactRequest.cc
+	src/model/DeleteArtifactResult.cc
+	src/model/GetArtifactRequest.cc
+	src/model/GetArtifactResult.cc
+	src/model/GetArtifactRepositoryCredentialsRequest.cc
+	src/model/GetArtifactRepositoryCredentialsResult.cc
+	src/model/GetServiceInstanceRequest.cc
+	src/model/GetServiceInstanceResult.cc
+	src/model/ListArtifactVersionsRequest.cc
+	src/model/ListArtifactVersionsResult.cc
+	src/model/ListArtifactsRequest.cc
+	src/model/ListArtifactsResult.cc
+	src/model/ListServiceInstancesRequest.cc
+	src/model/ListServiceInstancesResult.cc
+	src/model/ReleaseArtifactRequest.cc
+	src/model/ReleaseArtifactResult.cc
+	src/model/UpdateArtifactRequest.cc
+	src/model/UpdateArtifactResult.cc )
+
+add_library(computenestsupplier ${LIB_TYPE}
+	${computenestsupplier_public_header}
+	${computenestsupplier_public_header_model}
+	${computenestsupplier_src})
+
+set_target_properties(computenestsupplier
+	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}computenestsupplier
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(computenestsupplier
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_COMPUTENESTSUPPLIER_LIBRARY)
+endif()
+
+target_include_directories(computenestsupplier
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(computenestsupplier
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(computenestsupplier
+		jsoncpp)
+	target_include_directories(computenestsupplier
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(computenestsupplier
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(computenestsupplier
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(computenestsupplier
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(computenestsupplier
+		jsoncpp)
+endif()
+
+install(FILES ${computenestsupplier_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenestsupplier)
+install(FILES ${computenestsupplier_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/computenestsupplier/model)
+install(TARGETS computenestsupplier
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

computenestsupplier/include/alibabacloud/computenestsupplier/ComputeNestSupplierClient.h

@@ -0,0 +1,126 @@
+/*
+ * 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_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIERCLIENT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIERCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ComputeNestSupplierExport.h"
+#include "model/CreateArtifactRequest.h"
+#include "model/CreateArtifactResult.h"
+#include "model/DeleteArtifactRequest.h"
+#include "model/DeleteArtifactResult.h"
+#include "model/GetArtifactRequest.h"
+#include "model/GetArtifactResult.h"
+#include "model/GetArtifactRepositoryCredentialsRequest.h"
+#include "model/GetArtifactRepositoryCredentialsResult.h"
+#include "model/GetServiceInstanceRequest.h"
+#include "model/GetServiceInstanceResult.h"
+#include "model/ListArtifactVersionsRequest.h"
+#include "model/ListArtifactVersionsResult.h"
+#include "model/ListArtifactsRequest.h"
+#include "model/ListArtifactsResult.h"
+#include "model/ListServiceInstancesRequest.h"
+#include "model/ListServiceInstancesResult.h"
+#include "model/ReleaseArtifactRequest.h"
+#include "model/ReleaseArtifactResult.h"
+#include "model/UpdateArtifactRequest.h"
+#include "model/UpdateArtifactResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ComputeNestSupplierClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateArtifactResult> CreateArtifactOutcome;
+			typedef std::future<CreateArtifactOutcome> CreateArtifactOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::CreateArtifactRequest&, const CreateArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateArtifactAsyncHandler;
+			typedef Outcome<Error, Model::DeleteArtifactResult> DeleteArtifactOutcome;
+			typedef std::future<DeleteArtifactOutcome> DeleteArtifactOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::DeleteArtifactRequest&, const DeleteArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteArtifactAsyncHandler;
+			typedef Outcome<Error, Model::GetArtifactResult> GetArtifactOutcome;
+			typedef std::future<GetArtifactOutcome> GetArtifactOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::GetArtifactRequest&, const GetArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetArtifactAsyncHandler;
+			typedef Outcome<Error, Model::GetArtifactRepositoryCredentialsResult> GetArtifactRepositoryCredentialsOutcome;
+			typedef std::future<GetArtifactRepositoryCredentialsOutcome> GetArtifactRepositoryCredentialsOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::GetArtifactRepositoryCredentialsRequest&, const GetArtifactRepositoryCredentialsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetArtifactRepositoryCredentialsAsyncHandler;
+			typedef Outcome<Error, Model::GetServiceInstanceResult> GetServiceInstanceOutcome;
+			typedef std::future<GetServiceInstanceOutcome> GetServiceInstanceOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::GetServiceInstanceRequest&, const GetServiceInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetServiceInstanceAsyncHandler;
+			typedef Outcome<Error, Model::ListArtifactVersionsResult> ListArtifactVersionsOutcome;
+			typedef std::future<ListArtifactVersionsOutcome> ListArtifactVersionsOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::ListArtifactVersionsRequest&, const ListArtifactVersionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListArtifactVersionsAsyncHandler;
+			typedef Outcome<Error, Model::ListArtifactsResult> ListArtifactsOutcome;
+			typedef std::future<ListArtifactsOutcome> ListArtifactsOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::ListArtifactsRequest&, const ListArtifactsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListArtifactsAsyncHandler;
+			typedef Outcome<Error, Model::ListServiceInstancesResult> ListServiceInstancesOutcome;
+			typedef std::future<ListServiceInstancesOutcome> ListServiceInstancesOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::ListServiceInstancesRequest&, const ListServiceInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListServiceInstancesAsyncHandler;
+			typedef Outcome<Error, Model::ReleaseArtifactResult> ReleaseArtifactOutcome;
+			typedef std::future<ReleaseArtifactOutcome> ReleaseArtifactOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::ReleaseArtifactRequest&, const ReleaseArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseArtifactAsyncHandler;
+			typedef Outcome<Error, Model::UpdateArtifactResult> UpdateArtifactOutcome;
+			typedef std::future<UpdateArtifactOutcome> UpdateArtifactOutcomeCallable;
+			typedef std::function<void(const ComputeNestSupplierClient*, const Model::UpdateArtifactRequest&, const UpdateArtifactOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateArtifactAsyncHandler;
+
+			ComputeNestSupplierClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ComputeNestSupplierClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ComputeNestSupplierClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ComputeNestSupplierClient();
+			CreateArtifactOutcome createArtifact(const Model::CreateArtifactRequest &request)const;
+			void createArtifactAsync(const Model::CreateArtifactRequest& request, const CreateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateArtifactOutcomeCallable createArtifactCallable(const Model::CreateArtifactRequest& request) const;
+			DeleteArtifactOutcome deleteArtifact(const Model::DeleteArtifactRequest &request)const;
+			void deleteArtifactAsync(const Model::DeleteArtifactRequest& request, const DeleteArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteArtifactOutcomeCallable deleteArtifactCallable(const Model::DeleteArtifactRequest& request) const;
+			GetArtifactOutcome getArtifact(const Model::GetArtifactRequest &request)const;
+			void getArtifactAsync(const Model::GetArtifactRequest& request, const GetArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetArtifactOutcomeCallable getArtifactCallable(const Model::GetArtifactRequest& request) const;
+			GetArtifactRepositoryCredentialsOutcome getArtifactRepositoryCredentials(const Model::GetArtifactRepositoryCredentialsRequest &request)const;
+			void getArtifactRepositoryCredentialsAsync(const Model::GetArtifactRepositoryCredentialsRequest& request, const GetArtifactRepositoryCredentialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetArtifactRepositoryCredentialsOutcomeCallable getArtifactRepositoryCredentialsCallable(const Model::GetArtifactRepositoryCredentialsRequest& 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;
+			ListArtifactVersionsOutcome listArtifactVersions(const Model::ListArtifactVersionsRequest &request)const;
+			void listArtifactVersionsAsync(const Model::ListArtifactVersionsRequest& request, const ListArtifactVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListArtifactVersionsOutcomeCallable listArtifactVersionsCallable(const Model::ListArtifactVersionsRequest& request) const;
+			ListArtifactsOutcome listArtifacts(const Model::ListArtifactsRequest &request)const;
+			void listArtifactsAsync(const Model::ListArtifactsRequest& request, const ListArtifactsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListArtifactsOutcomeCallable listArtifactsCallable(const Model::ListArtifactsRequest& 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;
+			ReleaseArtifactOutcome releaseArtifact(const Model::ReleaseArtifactRequest &request)const;
+			void releaseArtifactAsync(const Model::ReleaseArtifactRequest& request, const ReleaseArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReleaseArtifactOutcomeCallable releaseArtifactCallable(const Model::ReleaseArtifactRequest& request) const;
+			UpdateArtifactOutcome updateArtifact(const Model::UpdateArtifactRequest &request)const;
+			void updateArtifactAsync(const Model::UpdateArtifactRequest& request, const UpdateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateArtifactOutcomeCallable updateArtifactCallable(const Model::UpdateArtifactRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIERCLIENT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/ComputeNestSupplierExport.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_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIEREXPORT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIEREXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_COMPUTENESTSUPPLIER_LIBRARY)
+#		define ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_COMPUTENESTSUPPLIEREXPORT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/CreateArtifactRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT CreateArtifactRequest : public RpcServiceRequest {
+public:
+	CreateArtifactRequest();
+	~CreateArtifactRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::vector<std::string> getSupportRegionIds() const;
+	void setSupportRegionIds(const std::vector<std::string> &supportRegionIds);
+	std::string getArtifactType() const;
+	void setArtifactType(const std::string &artifactType);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getArtifactId() const;
+	void setArtifactId(const std::string &artifactId);
+	std::string getArtifactProperty() const;
+	void setArtifactProperty(const std::string &artifactProperty);
+	std::string getVersionName() const;
+	void setVersionName(const std::string &versionName);
+
+private:
+	std::string description_;
+	std::vector<std::string> supportRegionIds_;
+	std::string artifactType_;
+	std::string name_;
+	std::string artifactId_;
+	std::string artifactProperty_;
+	std::string versionName_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/CreateArtifactResult.h

@@ -0,0 +1,71 @@
+/*
+ * 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_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT CreateArtifactResult : public ServiceResult
+			{
+			public:
+
+
+				CreateArtifactResult();
+				explicit CreateArtifactResult(const std::string &payload);
+				~CreateArtifactResult();
+				std::string getStatus()const;
+				std::string getArtifactVersion()const;
+				std::string getDescription()const;
+				std::string getArtifactId()const;
+				std::string getArtifactType()const;
+				std::string getSupportRegionIds()const;
+				std::string getGmtModified()const;
+				std::string getVersionName()const;
+				long getMaxVersion()const;
+				std::string getArtifactProperty()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string artifactVersion_;
+				std::string description_;
+				std::string artifactId_;
+				std::string artifactType_;
+				std::string supportRegionIds_;
+				std::string gmtModified_;
+				std::string versionName_;
+				long maxVersion_;
+				std::string artifactProperty_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_CREATEARTIFACTRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/DeleteArtifactRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT DeleteArtifactRequest : public RpcServiceRequest {
+public:
+	DeleteArtifactRequest();
+	~DeleteArtifactRequest();
+	std::string getArtifactVersion() const;
+	void setArtifactVersion(const std::string &artifactVersion);
+	std::string getArtifactId() const;
+	void setArtifactId(const std::string &artifactId);
+
+private:
+	std::string artifactVersion_;
+	std::string artifactId_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/DeleteArtifactResult.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_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT DeleteArtifactResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteArtifactResult();
+				explicit DeleteArtifactResult(const std::string &payload);
+				~DeleteArtifactResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_DELETEARTIFACTRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactRepositoryCredentialsRequest : public RpcServiceRequest {
+public:
+	GetArtifactRepositoryCredentialsRequest();
+	~GetArtifactRepositoryCredentialsRequest();
+	std::string getDeployRegionId() const;
+	void setDeployRegionId(const std::string &deployRegionId);
+	std::string getArtifactType() const;
+	void setArtifactType(const std::string &artifactType);
+
+private:
+	std::string deployRegionId_;
+	std::string artifactType_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactRepositoryCredentialsResult : public ServiceResult
+			{
+			public:
+				struct Credentials
+				{
+					std::string securityToken;
+					std::string username;
+					std::string accessKeyId;
+					std::string accessKeySecret;
+					std::string password;
+				};
+				struct AvailableResourcesItem
+				{
+					std::string path;
+					std::string repositoryName;
+					std::string regionId;
+				};
+
+
+				GetArtifactRepositoryCredentialsResult();
+				explicit GetArtifactRepositoryCredentialsResult(const std::string &payload);
+				~GetArtifactRepositoryCredentialsResult();
+				std::string getExpireDate()const;
+				std::vector<AvailableResourcesItem> getAvailableResources()const;
+				Credentials getCredentials()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string expireDate_;
+				std::vector<AvailableResourcesItem> availableResources_;
+				Credentials credentials_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREPOSITORYCREDENTIALSRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/GetArtifactRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactRequest : public RpcServiceRequest {
+public:
+	GetArtifactRequest();
+	~GetArtifactRequest();
+	std::string getArtifactVersion() const;
+	void setArtifactVersion(const std::string &artifactVersion);
+	std::string getArtifactId() const;
+	void setArtifactId(const std::string &artifactId);
+
+private:
+	std::string artifactVersion_;
+	std::string artifactId_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/GetArtifactResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT GetArtifactResult : public ServiceResult
+			{
+			public:
+
+
+				GetArtifactResult();
+				explicit GetArtifactResult(const std::string &payload);
+				~GetArtifactResult();
+				std::string getStatus()const;
+				std::string getProgress()const;
+				std::string getArtifactVersion()const;
+				std::string getDescription()const;
+				std::string getArtifactId()const;
+				std::string getArtifactType()const;
+				std::string getSupportRegionIds()const;
+				std::string getGmtModified()const;
+				std::string getVersionName()const;
+				long getMaxVersion()const;
+				std::string getArtifactProperty()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string progress_;
+				std::string artifactVersion_;
+				std::string description_;
+				std::string artifactId_;
+				std::string artifactType_;
+				std::string supportRegionIds_;
+				std::string gmtModified_;
+				std::string versionName_;
+				long maxVersion_;
+				std::string artifactProperty_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETARTIFACTRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/GetServiceInstanceRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCEREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCEREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_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);
+
+private:
+	std::string regionId_;
+	std::string serviceInstanceId_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCEREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/GetServiceInstanceResult.h

@@ -0,0 +1,146 @@
+/*
+ * 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_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCERESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_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::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 serviceDocUrl;
+				};
+				struct NetworkConfig
+				{
+					struct PrivateVpcConnection
+					{
+						std::string endpointServiceId;
+						std::string endpointId;
+					};
+					struct ReversePrivateVpcConnection
+					{
+						std::string endpointServiceId;
+						std::string endpointId;
+					};
+					std::string endpointServiceId;
+					std::vector<ReversePrivateVpcConnection> reversePrivateVpcConnections;
+					std::string endpointId;
+					std::vector<PrivateVpcConnection> privateVpcConnections;
+				};
+				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 getOperationEndTime()const;
+				bool getEnableInstanceOps()const;
+				std::string getSource()const;
+				std::string getName()const;
+				std::string getOperationStartTime()const;
+				std::string getServiceInstanceId()const;
+				std::string getServiceType()const;
+				std::string getLicenseMetadata()const;
+				std::string getTemplateName()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;
+				long getUserId()const;
+				std::string getStatusDetail()const;
+				std::string getUpdateTime()const;
+				std::string getOutputs()const;
+				long getSupplierUid()const;
+				bool getIsOperated()const;
+				std::string getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string operatedServiceInstanceId_;
+				std::string endTime_;
+				std::string operationEndTime_;
+				bool enableInstanceOps_;
+				std::string source_;
+				std::string name_;
+				std::string operationStartTime_;
+				std::string serviceInstanceId_;
+				std::string serviceType_;
+				std::string licenseMetadata_;
+				std::string templateName_;
+				std::vector<Tag> tags_;
+				std::string status_;
+				long progress_;
+				std::string parameters_;
+				std::string createTime_;
+				NetworkConfig networkConfig_;
+				Service service_;
+				std::string payType_;
+				long userId_;
+				std::string statusDetail_;
+				std::string updateTime_;
+				std::string outputs_;
+				long supplierUid_;
+				bool isOperated_;
+				std::string resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_GETSERVICEINSTANCERESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ListArtifactVersionsRequest.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_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactVersionsRequest : public RpcServiceRequest {
+public:
+	ListArtifactVersionsRequest();
+	~ListArtifactVersionsRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getMaxResult() const;
+	void setMaxResult(const std::string &maxResult);
+	std::string getArtifactId() const;
+	void setArtifactId(const std::string &artifactId);
+
+private:
+	std::string nextToken_;
+	std::string maxResult_;
+	std::string artifactId_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ListArtifactVersionsResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactVersionsResult : public ServiceResult
+			{
+			public:
+				struct Artifact
+				{
+					std::string status;
+					std::string progress;
+					std::string artifactId;
+					std::string supportRegionIds;
+					std::string gmtModified;
+					std::string imageDelivery;
+					std::string resultFile;
+					std::string securityAuditResult;
+					std::string gmtCreate;
+					std::string artifactVersion;
+					std::string artifactType;
+					std::string versionName;
+					std::string artifactProperty;
+				};
+
+
+				ListArtifactVersionsResult();
+				explicit ListArtifactVersionsResult(const std::string &payload);
+				~ListArtifactVersionsResult();
+				std::vector<Artifact> getArtifacts()const;
+				std::string getTotalCount()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Artifact> artifacts_;
+				std::string totalCount_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTVERSIONSRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ListArtifactsRequest.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_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactsRequest : public RpcServiceRequest {
+public:
+	struct Filter {
+		std::string name;
+	};
+	ListArtifactsRequest();
+	~ListArtifactsRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	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 nextToken_;
+	std::vector<Filter> filter_;
+	std::string maxResults_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ListArtifactsResult.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_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListArtifactsResult : public ServiceResult
+			{
+			public:
+				struct Artifact
+				{
+					std::string status;
+					std::string description;
+					std::string artifactId;
+					std::string artifactType;
+					std::string gmtModified;
+					std::string maxVersion;
+					std::string name;
+				};
+
+
+				ListArtifactsResult();
+				explicit ListArtifactsResult(const std::string &payload);
+				~ListArtifactsResult();
+				std::vector<Artifact> getArtifacts()const;
+				std::string getTotalCount()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Artifact> artifacts_;
+				std::string totalCount_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTARTIFACTSRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ListServiceInstancesRequest.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ListServiceInstancesRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	struct Filter {
+		std::string name;
+	};
+	ListServiceInstancesRequest();
+	~ListServiceInstancesRequest();
+	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 regionId_;
+	std::string nextToken_;
+	std::vector<Tag> tag_;
+	std::vector<Filter> filter_;
+	std::string maxResults_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ListServiceInstancesResult.h

@@ -0,0 +1,106 @@
+/*
+ * 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_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_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 deployMetadata;
+						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 operationEndTime;
+					std::string createTime;
+					bool enableInstanceOps;
+					Service service;
+					std::string payType;
+					std::string source;
+					std::string name;
+					std::string operationStartTime;
+					std::string serviceInstanceId;
+					long userId;
+					std::string serviceType;
+					std::string statusDetail;
+					std::string updateTime;
+					std::string templateName;
+					std::vector<ServiceInstance::Tag> tags;
+				};
+
+
+				ListServiceInstancesResult();
+				explicit ListServiceInstancesResult(const std::string &payload);
+				~ListServiceInstancesResult();
+				int getTotalCount()const;
+				std::vector<ServiceInstance> getServiceInstances()const;
+				std::string getNextToken()const;
+				std::string getMaxResults()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<ServiceInstance> serviceInstances_;
+				std::string nextToken_;
+				std::string maxResults_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_LISTSERVICEINSTANCESRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/ReleaseArtifactRequest.h

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

computenestsupplier/include/alibabacloud/computenestsupplier/model/ReleaseArtifactResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT ReleaseArtifactResult : public ServiceResult
+			{
+			public:
+
+
+				ReleaseArtifactResult();
+				explicit ReleaseArtifactResult(const std::string &payload);
+				~ReleaseArtifactResult();
+				std::string getStatus()const;
+				std::string getArtifactVersion()const;
+				std::string getDescription()const;
+				std::string getArtifactId()const;
+				std::string getArtifactType()const;
+				std::string getGmtModified()const;
+				std::string getVersionName()const;
+				std::string getArtifactProperty()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string artifactVersion_;
+				std::string description_;
+				std::string artifactId_;
+				std::string artifactType_;
+				std::string gmtModified_;
+				std::string versionName_;
+				std::string artifactProperty_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_RELEASEARTIFACTRESULT_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/UpdateArtifactRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTREQUEST_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTREQUEST_H_
+
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ComputeNestSupplier {
+namespace Model {
+class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT UpdateArtifactRequest : public RpcServiceRequest {
+public:
+	UpdateArtifactRequest();
+	~UpdateArtifactRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::vector<std::string> getSupportRegionIds() const;
+	void setSupportRegionIds(const std::vector<std::string> &supportRegionIds);
+	std::string getArtifactId() const;
+	void setArtifactId(const std::string &artifactId);
+	std::string getArtifactProperty() const;
+	void setArtifactProperty(const std::string &artifactProperty);
+	std::string getVersionName() const;
+	void setVersionName(const std::string &versionName);
+
+private:
+	std::string description_;
+	std::vector<std::string> supportRegionIds_;
+	std::string artifactId_;
+	std::string artifactProperty_;
+	std::string versionName_;
+};
+} // namespace Model
+} // namespace ComputeNestSupplier
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTREQUEST_H_

computenestsupplier/include/alibabacloud/computenestsupplier/model/UpdateArtifactResult.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_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTRESULT_H_
+#define ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/computenestsupplier/ComputeNestSupplierExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ComputeNestSupplier
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_COMPUTENESTSUPPLIER_EXPORT UpdateArtifactResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateArtifactResult();
+				explicit UpdateArtifactResult(const std::string &payload);
+				~UpdateArtifactResult();
+				std::string getStatus()const;
+				std::string getArtifactVersion()const;
+				std::string getDescription()const;
+				std::string getArtifactId()const;
+				std::string getArtifactType()const;
+				std::string getSupportRegionIds()const;
+				std::string getGmtModified()const;
+				std::string getVersionName()const;
+				std::string getArtifactProperty()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string artifactVersion_;
+				std::string description_;
+				std::string artifactId_;
+				std::string artifactType_;
+				std::string supportRegionIds_;
+				std::string gmtModified_;
+				std::string versionName_;
+				std::string artifactProperty_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_COMPUTENESTSUPPLIER_MODEL_UPDATEARTIFACTRESULT_H_

computenestsupplier/src/ComputeNestSupplierClient.cc

@@ -0,0 +1,413 @@
+/*
+ * 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/computenestsupplier/ComputeNestSupplierClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "ComputeNestSupplier";
+}
+
+ComputeNestSupplierClient::ComputeNestSupplierClient(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, "");
+}
+
+ComputeNestSupplierClient::ComputeNestSupplierClient(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, "");
+}
+
+ComputeNestSupplierClient::ComputeNestSupplierClient(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, "");
+}
+
+ComputeNestSupplierClient::~ComputeNestSupplierClient()
+{}
+
+ComputeNestSupplierClient::CreateArtifactOutcome ComputeNestSupplierClient::createArtifact(const CreateArtifactRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateArtifactOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateArtifactOutcome(CreateArtifactResult(outcome.result()));
+	else
+		return CreateArtifactOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::createArtifactAsync(const CreateArtifactRequest& request, const CreateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createArtifact(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::CreateArtifactOutcomeCallable ComputeNestSupplierClient::createArtifactCallable(const CreateArtifactRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateArtifactOutcome()>>(
+			[this, request]()
+			{
+			return this->createArtifact(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::DeleteArtifactOutcome ComputeNestSupplierClient::deleteArtifact(const DeleteArtifactRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteArtifactOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteArtifactOutcome(DeleteArtifactResult(outcome.result()));
+	else
+		return DeleteArtifactOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::deleteArtifactAsync(const DeleteArtifactRequest& request, const DeleteArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteArtifact(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::DeleteArtifactOutcomeCallable ComputeNestSupplierClient::deleteArtifactCallable(const DeleteArtifactRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteArtifactOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteArtifact(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::GetArtifactOutcome ComputeNestSupplierClient::getArtifact(const GetArtifactRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetArtifactOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetArtifactOutcome(GetArtifactResult(outcome.result()));
+	else
+		return GetArtifactOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::getArtifactAsync(const GetArtifactRequest& request, const GetArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getArtifact(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::GetArtifactOutcomeCallable ComputeNestSupplierClient::getArtifactCallable(const GetArtifactRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetArtifactOutcome()>>(
+			[this, request]()
+			{
+			return this->getArtifact(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::GetArtifactRepositoryCredentialsOutcome ComputeNestSupplierClient::getArtifactRepositoryCredentials(const GetArtifactRepositoryCredentialsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetArtifactRepositoryCredentialsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetArtifactRepositoryCredentialsOutcome(GetArtifactRepositoryCredentialsResult(outcome.result()));
+	else
+		return GetArtifactRepositoryCredentialsOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::getArtifactRepositoryCredentialsAsync(const GetArtifactRepositoryCredentialsRequest& request, const GetArtifactRepositoryCredentialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getArtifactRepositoryCredentials(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::GetArtifactRepositoryCredentialsOutcomeCallable ComputeNestSupplierClient::getArtifactRepositoryCredentialsCallable(const GetArtifactRepositoryCredentialsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetArtifactRepositoryCredentialsOutcome()>>(
+			[this, request]()
+			{
+			return this->getArtifactRepositoryCredentials(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::GetServiceInstanceOutcome ComputeNestSupplierClient::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 ComputeNestSupplierClient::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));
+}
+
+ComputeNestSupplierClient::GetServiceInstanceOutcomeCallable ComputeNestSupplierClient::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();
+}
+
+ComputeNestSupplierClient::ListArtifactVersionsOutcome ComputeNestSupplierClient::listArtifactVersions(const ListArtifactVersionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListArtifactVersionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListArtifactVersionsOutcome(ListArtifactVersionsResult(outcome.result()));
+	else
+		return ListArtifactVersionsOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::listArtifactVersionsAsync(const ListArtifactVersionsRequest& request, const ListArtifactVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listArtifactVersions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::ListArtifactVersionsOutcomeCallable ComputeNestSupplierClient::listArtifactVersionsCallable(const ListArtifactVersionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListArtifactVersionsOutcome()>>(
+			[this, request]()
+			{
+			return this->listArtifactVersions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::ListArtifactsOutcome ComputeNestSupplierClient::listArtifacts(const ListArtifactsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListArtifactsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListArtifactsOutcome(ListArtifactsResult(outcome.result()));
+	else
+		return ListArtifactsOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::listArtifactsAsync(const ListArtifactsRequest& request, const ListArtifactsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listArtifacts(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::ListArtifactsOutcomeCallable ComputeNestSupplierClient::listArtifactsCallable(const ListArtifactsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListArtifactsOutcome()>>(
+			[this, request]()
+			{
+			return this->listArtifacts(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::ListServiceInstancesOutcome ComputeNestSupplierClient::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 ComputeNestSupplierClient::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));
+}
+
+ComputeNestSupplierClient::ListServiceInstancesOutcomeCallable ComputeNestSupplierClient::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();
+}
+
+ComputeNestSupplierClient::ReleaseArtifactOutcome ComputeNestSupplierClient::releaseArtifact(const ReleaseArtifactRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReleaseArtifactOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReleaseArtifactOutcome(ReleaseArtifactResult(outcome.result()));
+	else
+		return ReleaseArtifactOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::releaseArtifactAsync(const ReleaseArtifactRequest& request, const ReleaseArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, releaseArtifact(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::ReleaseArtifactOutcomeCallable ComputeNestSupplierClient::releaseArtifactCallable(const ReleaseArtifactRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReleaseArtifactOutcome()>>(
+			[this, request]()
+			{
+			return this->releaseArtifact(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ComputeNestSupplierClient::UpdateArtifactOutcome ComputeNestSupplierClient::updateArtifact(const UpdateArtifactRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateArtifactOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateArtifactOutcome(UpdateArtifactResult(outcome.result()));
+	else
+		return UpdateArtifactOutcome(outcome.error());
+}
+
+void ComputeNestSupplierClient::updateArtifactAsync(const UpdateArtifactRequest& request, const UpdateArtifactAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateArtifact(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ComputeNestSupplierClient::UpdateArtifactOutcomeCallable ComputeNestSupplierClient::updateArtifactCallable(const UpdateArtifactRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateArtifactOutcome()>>(
+			[this, request]()
+			{
+			return this->updateArtifact(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

computenestsupplier/src/model/CreateArtifactRequest.cc

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenestsupplier/model/CreateArtifactRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::CreateArtifactRequest;
+
+CreateArtifactRequest::CreateArtifactRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "CreateArtifact") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateArtifactRequest::~CreateArtifactRequest() {}
+
+std::string CreateArtifactRequest::getDescription() const {
+  return description_;
+}
+
+void CreateArtifactRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::vector<std::string> CreateArtifactRequest::getSupportRegionIds() const {
+  return supportRegionIds_;
+}
+
+void CreateArtifactRequest::setSupportRegionIds(const std::vector<std::string> &supportRegionIds) {
+  supportRegionIds_ = supportRegionIds;
+}
+
+std::string CreateArtifactRequest::getArtifactType() const {
+  return artifactType_;
+}
+
+void CreateArtifactRequest::setArtifactType(const std::string &artifactType) {
+  artifactType_ = artifactType;
+  setParameter(std::string("ArtifactType"), artifactType);
+}
+
+std::string CreateArtifactRequest::getName() const {
+  return name_;
+}
+
+void CreateArtifactRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string CreateArtifactRequest::getArtifactId() const {
+  return artifactId_;
+}
+
+void CreateArtifactRequest::setArtifactId(const std::string &artifactId) {
+  artifactId_ = artifactId;
+  setParameter(std::string("ArtifactId"), artifactId);
+}
+
+std::string CreateArtifactRequest::getArtifactProperty() const {
+  return artifactProperty_;
+}
+
+void CreateArtifactRequest::setArtifactProperty(const std::string &artifactProperty) {
+  artifactProperty_ = artifactProperty;
+  setParameter(std::string("ArtifactProperty"), artifactProperty);
+}
+
+std::string CreateArtifactRequest::getVersionName() const {
+  return versionName_;
+}
+
+void CreateArtifactRequest::setVersionName(const std::string &versionName) {
+  versionName_ = versionName;
+  setParameter(std::string("VersionName"), versionName);
+}
+

computenestsupplier/src/model/CreateArtifactResult.cc

@@ -0,0 +1,121 @@
+/*
+ * 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/computenestsupplier/model/CreateArtifactResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+CreateArtifactResult::CreateArtifactResult() :
+	ServiceResult()
+{}
+
+CreateArtifactResult::CreateArtifactResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateArtifactResult::~CreateArtifactResult()
+{}
+
+void CreateArtifactResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ArtifactId"].isNull())
+		artifactId_ = value["ArtifactId"].asString();
+	if(!value["ArtifactType"].isNull())
+		artifactType_ = value["ArtifactType"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["VersionName"].isNull())
+		versionName_ = value["VersionName"].asString();
+	if(!value["ArtifactVersion"].isNull())
+		artifactVersion_ = value["ArtifactVersion"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["GmtModified"].isNull())
+		gmtModified_ = value["GmtModified"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["MaxVersion"].isNull())
+		maxVersion_ = std::stol(value["MaxVersion"].asString());
+	if(!value["ArtifactProperty"].isNull())
+		artifactProperty_ = value["ArtifactProperty"].asString();
+	if(!value["SupportRegionIds"].isNull())
+		supportRegionIds_ = value["SupportRegionIds"].asString();
+
+}
+
+std::string CreateArtifactResult::getStatus()const
+{
+	return status_;
+}
+
+std::string CreateArtifactResult::getArtifactVersion()const
+{
+	return artifactVersion_;
+}
+
+std::string CreateArtifactResult::getDescription()const
+{
+	return description_;
+}
+
+std::string CreateArtifactResult::getArtifactId()const
+{
+	return artifactId_;
+}
+
+std::string CreateArtifactResult::getArtifactType()const
+{
+	return artifactType_;
+}
+
+std::string CreateArtifactResult::getSupportRegionIds()const
+{
+	return supportRegionIds_;
+}
+
+std::string CreateArtifactResult::getGmtModified()const
+{
+	return gmtModified_;
+}
+
+std::string CreateArtifactResult::getVersionName()const
+{
+	return versionName_;
+}
+
+long CreateArtifactResult::getMaxVersion()const
+{
+	return maxVersion_;
+}
+
+std::string CreateArtifactResult::getArtifactProperty()const
+{
+	return artifactProperty_;
+}
+
+std::string CreateArtifactResult::getName()const
+{
+	return name_;
+}
+

computenestsupplier/src/model/DeleteArtifactRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenestsupplier/model/DeleteArtifactRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::DeleteArtifactRequest;
+
+DeleteArtifactRequest::DeleteArtifactRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "DeleteArtifact") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteArtifactRequest::~DeleteArtifactRequest() {}
+
+std::string DeleteArtifactRequest::getArtifactVersion() const {
+  return artifactVersion_;
+}
+
+void DeleteArtifactRequest::setArtifactVersion(const std::string &artifactVersion) {
+  artifactVersion_ = artifactVersion;
+  setParameter(std::string("ArtifactVersion"), artifactVersion);
+}
+
+std::string DeleteArtifactRequest::getArtifactId() const {
+  return artifactId_;
+}
+
+void DeleteArtifactRequest::setArtifactId(const std::string &artifactId) {
+  artifactId_ = artifactId;
+  setParameter(std::string("ArtifactId"), artifactId);
+}
+

computenestsupplier/src/model/DeleteArtifactResult.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/computenestsupplier/model/DeleteArtifactResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+DeleteArtifactResult::DeleteArtifactResult() :
+	ServiceResult()
+{}
+
+DeleteArtifactResult::DeleteArtifactResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteArtifactResult::~DeleteArtifactResult()
+{}
+
+void DeleteArtifactResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

computenestsupplier/src/model/GetArtifactRepositoryCredentialsRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::GetArtifactRepositoryCredentialsRequest;
+
+GetArtifactRepositoryCredentialsRequest::GetArtifactRepositoryCredentialsRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "GetArtifactRepositoryCredentials") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetArtifactRepositoryCredentialsRequest::~GetArtifactRepositoryCredentialsRequest() {}
+
+std::string GetArtifactRepositoryCredentialsRequest::getDeployRegionId() const {
+  return deployRegionId_;
+}
+
+void GetArtifactRepositoryCredentialsRequest::setDeployRegionId(const std::string &deployRegionId) {
+  deployRegionId_ = deployRegionId;
+  setParameter(std::string("DeployRegionId"), deployRegionId);
+}
+
+std::string GetArtifactRepositoryCredentialsRequest::getArtifactType() const {
+  return artifactType_;
+}
+
+void GetArtifactRepositoryCredentialsRequest::setArtifactType(const std::string &artifactType) {
+  artifactType_ = artifactType;
+  setParameter(std::string("ArtifactType"), artifactType);
+}
+

computenestsupplier/src/model/GetArtifactRepositoryCredentialsResult.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenestsupplier/model/GetArtifactRepositoryCredentialsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+GetArtifactRepositoryCredentialsResult::GetArtifactRepositoryCredentialsResult() :
+	ServiceResult()
+{}
+
+GetArtifactRepositoryCredentialsResult::GetArtifactRepositoryCredentialsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetArtifactRepositoryCredentialsResult::~GetArtifactRepositoryCredentialsResult()
+{}
+
+void GetArtifactRepositoryCredentialsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAvailableResourcesNode = value["AvailableResources"]["availableResourcesItem"];
+	for (auto valueAvailableResourcesavailableResourcesItem : allAvailableResourcesNode)
+	{
+		AvailableResourcesItem availableResourcesObject;
+		if(!valueAvailableResourcesavailableResourcesItem["RegionId"].isNull())
+			availableResourcesObject.regionId = valueAvailableResourcesavailableResourcesItem["RegionId"].asString();
+		if(!valueAvailableResourcesavailableResourcesItem["RepositoryName"].isNull())
+			availableResourcesObject.repositoryName = valueAvailableResourcesavailableResourcesItem["RepositoryName"].asString();
+		if(!valueAvailableResourcesavailableResourcesItem["Path"].isNull())
+			availableResourcesObject.path = valueAvailableResourcesavailableResourcesItem["Path"].asString();
+		availableResources_.push_back(availableResourcesObject);
+	}
+	auto credentialsNode = value["Credentials"];
+	if(!credentialsNode["Username"].isNull())
+		credentials_.username = credentialsNode["Username"].asString();
+	if(!credentialsNode["Password"].isNull())
+		credentials_.password = credentialsNode["Password"].asString();
+	if(!credentialsNode["AccessKeyId"].isNull())
+		credentials_.accessKeyId = credentialsNode["AccessKeyId"].asString();
+	if(!credentialsNode["AccessKeySecret"].isNull())
+		credentials_.accessKeySecret = credentialsNode["AccessKeySecret"].asString();
+	if(!credentialsNode["SecurityToken"].isNull())
+		credentials_.securityToken = credentialsNode["SecurityToken"].asString();
+	if(!value["ExpireDate"].isNull())
+		expireDate_ = value["ExpireDate"].asString();
+
+}
+
+std::string GetArtifactRepositoryCredentialsResult::getExpireDate()const
+{
+	return expireDate_;
+}
+
+std::vector<GetArtifactRepositoryCredentialsResult::AvailableResourcesItem> GetArtifactRepositoryCredentialsResult::getAvailableResources()const
+{
+	return availableResources_;
+}
+
+GetArtifactRepositoryCredentialsResult::Credentials GetArtifactRepositoryCredentialsResult::getCredentials()const
+{
+	return credentials_;
+}
+

computenestsupplier/src/model/GetArtifactRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenestsupplier/model/GetArtifactRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::GetArtifactRequest;
+
+GetArtifactRequest::GetArtifactRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "GetArtifact") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetArtifactRequest::~GetArtifactRequest() {}
+
+std::string GetArtifactRequest::getArtifactVersion() const {
+  return artifactVersion_;
+}
+
+void GetArtifactRequest::setArtifactVersion(const std::string &artifactVersion) {
+  artifactVersion_ = artifactVersion;
+  setParameter(std::string("ArtifactVersion"), artifactVersion);
+}
+
+std::string GetArtifactRequest::getArtifactId() const {
+  return artifactId_;
+}
+
+void GetArtifactRequest::setArtifactId(const std::string &artifactId) {
+  artifactId_ = artifactId;
+  setParameter(std::string("ArtifactId"), artifactId);
+}
+

computenestsupplier/src/model/GetArtifactResult.cc

@@ -0,0 +1,128 @@
+/*
+ * 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/computenestsupplier/model/GetArtifactResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+GetArtifactResult::GetArtifactResult() :
+	ServiceResult()
+{}
+
+GetArtifactResult::GetArtifactResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetArtifactResult::~GetArtifactResult()
+{}
+
+void GetArtifactResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ArtifactId"].isNull())
+		artifactId_ = value["ArtifactId"].asString();
+	if(!value["ArtifactType"].isNull())
+		artifactType_ = value["ArtifactType"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["VersionName"].isNull())
+		versionName_ = value["VersionName"].asString();
+	if(!value["ArtifactVersion"].isNull())
+		artifactVersion_ = value["ArtifactVersion"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["GmtModified"].isNull())
+		gmtModified_ = value["GmtModified"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["MaxVersion"].isNull())
+		maxVersion_ = std::stol(value["MaxVersion"].asString());
+	if(!value["ArtifactProperty"].isNull())
+		artifactProperty_ = value["ArtifactProperty"].asString();
+	if(!value["SupportRegionIds"].isNull())
+		supportRegionIds_ = value["SupportRegionIds"].asString();
+	if(!value["Progress"].isNull())
+		progress_ = value["Progress"].asString();
+
+}
+
+std::string GetArtifactResult::getStatus()const
+{
+	return status_;
+}
+
+std::string GetArtifactResult::getProgress()const
+{
+	return progress_;
+}
+
+std::string GetArtifactResult::getArtifactVersion()const
+{
+	return artifactVersion_;
+}
+
+std::string GetArtifactResult::getDescription()const
+{
+	return description_;
+}
+
+std::string GetArtifactResult::getArtifactId()const
+{
+	return artifactId_;
+}
+
+std::string GetArtifactResult::getArtifactType()const
+{
+	return artifactType_;
+}
+
+std::string GetArtifactResult::getSupportRegionIds()const
+{
+	return supportRegionIds_;
+}
+
+std::string GetArtifactResult::getGmtModified()const
+{
+	return gmtModified_;
+}
+
+std::string GetArtifactResult::getVersionName()const
+{
+	return versionName_;
+}
+
+long GetArtifactResult::getMaxVersion()const
+{
+	return maxVersion_;
+}
+
+std::string GetArtifactResult::getArtifactProperty()const
+{
+	return artifactProperty_;
+}
+
+std::string GetArtifactResult::getName()const
+{
+	return name_;
+}
+

computenestsupplier/src/model/GetServiceInstanceRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/computenestsupplier/model/GetServiceInstanceRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::GetServiceInstanceRequest;
+
+GetServiceInstanceRequest::GetServiceInstanceRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "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);
+}
+

computenestsupplier/src/model/GetServiceInstanceResult.cc

@@ -0,0 +1,294 @@
+/*
+ * 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/computenestsupplier/model/GetServiceInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::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["ServiceProductUrl"].isNull())
+		service_.serviceProductUrl = serviceNode["ServiceProductUrl"].asString();
+	if(!serviceNode["ServiceDocUrl"].isNull())
+		service_.serviceDocUrl = serviceNode["ServiceDocUrl"].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();
+	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 networkConfigNode = value["NetworkConfig"];
+	if(!networkConfigNode["EndpointServiceId"].isNull())
+		networkConfig_.endpointServiceId = networkConfigNode["EndpointServiceId"].asString();
+	if(!networkConfigNode["EndpointId"].isNull())
+		networkConfig_.endpointId = networkConfigNode["EndpointId"].asString();
+	auto allPrivateVpcConnectionsNode = networkConfigNode["PrivateVpcConnections"]["PrivateVpcConnection"];
+	for (auto networkConfigNodePrivateVpcConnectionsPrivateVpcConnection : allPrivateVpcConnectionsNode)
+	{
+		NetworkConfig::PrivateVpcConnection privateVpcConnectionObject;
+		if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].isNull())
+			privateVpcConnectionObject.endpointId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointId"].asString();
+		if(!networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointServiceId"].isNull())
+			privateVpcConnectionObject.endpointServiceId = networkConfigNodePrivateVpcConnectionsPrivateVpcConnection["EndpointServiceId"].asString();
+		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();
+		if(!networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointServiceId"].isNull())
+			reversePrivateVpcConnectionObject.endpointServiceId = networkConfigNodeReversePrivateVpcConnectionsReversePrivateVpcConnection["EndpointServiceId"].asString();
+		networkConfig_.reversePrivateVpcConnections.push_back(reversePrivateVpcConnectionObject);
+	}
+	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["ServiceInstanceId"].isNull())
+		serviceInstanceId_ = value["ServiceInstanceId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["UserId"].isNull())
+		userId_ = std::stol(value["UserId"].asString());
+	if(!value["SupplierUid"].isNull())
+		supplierUid_ = std::stol(value["SupplierUid"].asString());
+	if(!value["Parameters"].isNull())
+		parameters_ = value["Parameters"].asString();
+	if(!value["Progress"].isNull())
+		progress_ = std::stol(value["Progress"].asString());
+	if(!value["StatusDetail"].isNull())
+		statusDetail_ = value["StatusDetail"].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["IsOperated"].isNull())
+		isOperated_ = value["IsOperated"].asString() == "true";
+	if(!value["EnableInstanceOps"].isNull())
+		enableInstanceOps_ = value["EnableInstanceOps"].asString() == "true";
+	if(!value["Resources"].isNull())
+		resources_ = value["Resources"].asString();
+	if(!value["Outputs"].isNull())
+		outputs_ = value["Outputs"].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["LicenseMetadata"].isNull())
+		licenseMetadata_ = value["LicenseMetadata"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+
+}
+
+std::string GetServiceInstanceResult::getOperatedServiceInstanceId()const
+{
+	return operatedServiceInstanceId_;
+}
+
+std::string GetServiceInstanceResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string GetServiceInstanceResult::getOperationEndTime()const
+{
+	return operationEndTime_;
+}
+
+bool GetServiceInstanceResult::getEnableInstanceOps()const
+{
+	return enableInstanceOps_;
+}
+
+std::string GetServiceInstanceResult::getSource()const
+{
+	return source_;
+}
+
+std::string GetServiceInstanceResult::getName()const
+{
+	return name_;
+}
+
+std::string GetServiceInstanceResult::getOperationStartTime()const
+{
+	return operationStartTime_;
+}
+
+std::string GetServiceInstanceResult::getServiceInstanceId()const
+{
+	return serviceInstanceId_;
+}
+
+std::string GetServiceInstanceResult::getServiceType()const
+{
+	return serviceType_;
+}
+
+std::string GetServiceInstanceResult::getLicenseMetadata()const
+{
+	return licenseMetadata_;
+}
+
+std::string GetServiceInstanceResult::getTemplateName()const
+{
+	return templateName_;
+}
+
+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_;
+}
+
+long GetServiceInstanceResult::getUserId()const
+{
+	return userId_;
+}
+
+std::string GetServiceInstanceResult::getStatusDetail()const
+{
+	return statusDetail_;
+}
+
+std::string GetServiceInstanceResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+std::string GetServiceInstanceResult::getOutputs()const
+{
+	return outputs_;
+}
+
+long GetServiceInstanceResult::getSupplierUid()const
+{
+	return supplierUid_;
+}
+
+bool GetServiceInstanceResult::getIsOperated()const
+{
+	return isOperated_;
+}
+
+std::string GetServiceInstanceResult::getResources()const
+{
+	return resources_;
+}
+

computenestsupplier/src/model/ListArtifactVersionsRequest.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/computenestsupplier/model/ListArtifactVersionsRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::ListArtifactVersionsRequest;
+
+ListArtifactVersionsRequest::ListArtifactVersionsRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "ListArtifactVersions") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListArtifactVersionsRequest::~ListArtifactVersionsRequest() {}
+
+std::string ListArtifactVersionsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListArtifactVersionsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListArtifactVersionsRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void ListArtifactVersionsRequest::setMaxResult(const std::string &maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), maxResult);
+}
+
+std::string ListArtifactVersionsRequest::getArtifactId() const {
+  return artifactId_;
+}
+
+void ListArtifactVersionsRequest::setArtifactId(const std::string &artifactId) {
+  artifactId_ = artifactId;
+  setParameter(std::string("ArtifactId"), artifactId);
+}
+

computenestsupplier/src/model/ListArtifactVersionsResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/computenestsupplier/model/ListArtifactVersionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+ListArtifactVersionsResult::ListArtifactVersionsResult() :
+	ServiceResult()
+{}
+
+ListArtifactVersionsResult::ListArtifactVersionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListArtifactVersionsResult::~ListArtifactVersionsResult()
+{}
+
+void ListArtifactVersionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allArtifactsNode = value["Artifacts"]["Artifact"];
+	for (auto valueArtifactsArtifact : allArtifactsNode)
+	{
+		Artifact artifactsObject;
+		if(!valueArtifactsArtifact["ArtifactId"].isNull())
+			artifactsObject.artifactId = valueArtifactsArtifact["ArtifactId"].asString();
+		if(!valueArtifactsArtifact["ArtifactType"].isNull())
+			artifactsObject.artifactType = valueArtifactsArtifact["ArtifactType"].asString();
+		if(!valueArtifactsArtifact["VersionName"].isNull())
+			artifactsObject.versionName = valueArtifactsArtifact["VersionName"].asString();
+		if(!valueArtifactsArtifact["ArtifactVersion"].isNull())
+			artifactsObject.artifactVersion = valueArtifactsArtifact["ArtifactVersion"].asString();
+		if(!valueArtifactsArtifact["Status"].isNull())
+			artifactsObject.status = valueArtifactsArtifact["Status"].asString();
+		if(!valueArtifactsArtifact["ArtifactProperty"].isNull())
+			artifactsObject.artifactProperty = valueArtifactsArtifact["ArtifactProperty"].asString();
+		if(!valueArtifactsArtifact["SupportRegionIds"].isNull())
+			artifactsObject.supportRegionIds = valueArtifactsArtifact["SupportRegionIds"].asString();
+		if(!valueArtifactsArtifact["GmtModified"].isNull())
+			artifactsObject.gmtModified = valueArtifactsArtifact["GmtModified"].asString();
+		if(!valueArtifactsArtifact["Progress"].isNull())
+			artifactsObject.progress = valueArtifactsArtifact["Progress"].asString();
+		if(!valueArtifactsArtifact["GmtCreate"].isNull())
+			artifactsObject.gmtCreate = valueArtifactsArtifact["GmtCreate"].asString();
+		if(!valueArtifactsArtifact["ImageDelivery"].isNull())
+			artifactsObject.imageDelivery = valueArtifactsArtifact["ImageDelivery"].asString();
+		if(!valueArtifactsArtifact["SecurityAuditResult"].isNull())
+			artifactsObject.securityAuditResult = valueArtifactsArtifact["SecurityAuditResult"].asString();
+		if(!valueArtifactsArtifact["ResultFile"].isNull())
+			artifactsObject.resultFile = valueArtifactsArtifact["ResultFile"].asString();
+		artifacts_.push_back(artifactsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = value["TotalCount"].asString();
+
+}
+
+std::vector<ListArtifactVersionsResult::Artifact> ListArtifactVersionsResult::getArtifacts()const
+{
+	return artifacts_;
+}
+
+std::string ListArtifactVersionsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string ListArtifactVersionsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListArtifactVersionsResult::getMaxResults()const
+{
+	return maxResults_;
+}
+

computenestsupplier/src/model/ListArtifactsRequest.cc

@@ -0,0 +1,58 @@
+/*
+ * 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/computenestsupplier/model/ListArtifactsRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::ListArtifactsRequest;
+
+ListArtifactsRequest::ListArtifactsRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "ListArtifacts") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListArtifactsRequest::~ListArtifactsRequest() {}
+
+std::string ListArtifactsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListArtifactsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::vector<ListArtifactsRequest::Filter> ListArtifactsRequest::getFilter() const {
+  return filter_;
+}
+
+void ListArtifactsRequest::setFilter(const std::vector<ListArtifactsRequest::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 ListArtifactsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListArtifactsRequest::setMaxResults(const std::string &maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), maxResults);
+}
+

computenestsupplier/src/model/ListArtifactsResult.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/computenestsupplier/model/ListArtifactsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+ListArtifactsResult::ListArtifactsResult() :
+	ServiceResult()
+{}
+
+ListArtifactsResult::ListArtifactsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListArtifactsResult::~ListArtifactsResult()
+{}
+
+void ListArtifactsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allArtifactsNode = value["Artifacts"]["Artifact"];
+	for (auto valueArtifactsArtifact : allArtifactsNode)
+	{
+		Artifact artifactsObject;
+		if(!valueArtifactsArtifact["ArtifactId"].isNull())
+			artifactsObject.artifactId = valueArtifactsArtifact["ArtifactId"].asString();
+		if(!valueArtifactsArtifact["ArtifactType"].isNull())
+			artifactsObject.artifactType = valueArtifactsArtifact["ArtifactType"].asString();
+		if(!valueArtifactsArtifact["Name"].isNull())
+			artifactsObject.name = valueArtifactsArtifact["Name"].asString();
+		if(!valueArtifactsArtifact["MaxVersion"].isNull())
+			artifactsObject.maxVersion = valueArtifactsArtifact["MaxVersion"].asString();
+		if(!valueArtifactsArtifact["Description"].isNull())
+			artifactsObject.description = valueArtifactsArtifact["Description"].asString();
+		if(!valueArtifactsArtifact["GmtModified"].isNull())
+			artifactsObject.gmtModified = valueArtifactsArtifact["GmtModified"].asString();
+		if(!valueArtifactsArtifact["Status"].isNull())
+			artifactsObject.status = valueArtifactsArtifact["Status"].asString();
+		artifacts_.push_back(artifactsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = value["TotalCount"].asString();
+
+}
+
+std::vector<ListArtifactsResult::Artifact> ListArtifactsResult::getArtifacts()const
+{
+	return artifacts_;
+}
+
+std::string ListArtifactsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string ListArtifactsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListArtifactsResult::getMaxResults()const
+{
+	return maxResults_;
+}
+

computenestsupplier/src/model/ListServiceInstancesRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * 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/computenestsupplier/model/ListServiceInstancesRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::ListServiceInstancesRequest;
+
+ListServiceInstancesRequest::ListServiceInstancesRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "ListServiceInstances") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListServiceInstancesRequest::~ListServiceInstancesRequest() {}
+
+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);
+}
+

computenestsupplier/src/model/ListServiceInstancesResult.cc

@@ -0,0 +1,157 @@
+/*
+ * 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/computenestsupplier/model/ListServiceInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::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["Status"].isNull())
+			serviceInstancesObject.status = valueServiceInstancesServiceInstance["Status"].asString();
+		if(!valueServiceInstancesServiceInstance["UpdateTime"].isNull())
+			serviceInstancesObject.updateTime = valueServiceInstancesServiceInstance["UpdateTime"].asString();
+		if(!valueServiceInstancesServiceInstance["Name"].isNull())
+			serviceInstancesObject.name = valueServiceInstancesServiceInstance["Name"].asString();
+		if(!valueServiceInstancesServiceInstance["ServiceInstanceId"].isNull())
+			serviceInstancesObject.serviceInstanceId = valueServiceInstancesServiceInstance["ServiceInstanceId"].asString();
+		if(!valueServiceInstancesServiceInstance["CreateTime"].isNull())
+			serviceInstancesObject.createTime = valueServiceInstancesServiceInstance["CreateTime"].asString();
+		if(!valueServiceInstancesServiceInstance["UserId"].isNull())
+			serviceInstancesObject.userId = std::stol(valueServiceInstancesServiceInstance["UserId"].asString());
+		if(!valueServiceInstancesServiceInstance["Parameters"].isNull())
+			serviceInstancesObject.parameters = valueServiceInstancesServiceInstance["Parameters"].asString();
+		if(!valueServiceInstancesServiceInstance["Progress"].isNull())
+			serviceInstancesObject.progress = std::stol(valueServiceInstancesServiceInstance["Progress"].asString());
+		if(!valueServiceInstancesServiceInstance["StatusDetail"].isNull())
+			serviceInstancesObject.statusDetail = valueServiceInstancesServiceInstance["StatusDetail"].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();
+		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();
+		if(!serviceNode["DeployMetadata"].isNull())
+			serviceInstancesObject.service.deployMetadata = serviceNode["DeployMetadata"].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::stoi(value["TotalCount"].asString());
+	if(!value["MaxResults"].isNull())
+		maxResults_ = value["MaxResults"].asString();
+
+}
+
+int 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_;
+}
+

computenestsupplier/src/model/ReleaseArtifactRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/computenestsupplier/model/ReleaseArtifactRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::ReleaseArtifactRequest;
+
+ReleaseArtifactRequest::ReleaseArtifactRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "ReleaseArtifact") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ReleaseArtifactRequest::~ReleaseArtifactRequest() {}
+
+std::string ReleaseArtifactRequest::getArtifactId() const {
+  return artifactId_;
+}
+
+void ReleaseArtifactRequest::setArtifactId(const std::string &artifactId) {
+  artifactId_ = artifactId;
+  setParameter(std::string("ArtifactId"), artifactId);
+}
+

computenestsupplier/src/model/ReleaseArtifactResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/computenestsupplier/model/ReleaseArtifactResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+ReleaseArtifactResult::ReleaseArtifactResult() :
+	ServiceResult()
+{}
+
+ReleaseArtifactResult::ReleaseArtifactResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ReleaseArtifactResult::~ReleaseArtifactResult()
+{}
+
+void ReleaseArtifactResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ArtifactId"].isNull())
+		artifactId_ = value["ArtifactId"].asString();
+	if(!value["ArtifactType"].isNull())
+		artifactType_ = value["ArtifactType"].asString();
+	if(!value["VersionName"].isNull())
+		versionName_ = value["VersionName"].asString();
+	if(!value["ArtifactVersion"].isNull())
+		artifactVersion_ = value["ArtifactVersion"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["GmtModified"].isNull())
+		gmtModified_ = value["GmtModified"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["ArtifactProperty"].isNull())
+		artifactProperty_ = value["ArtifactProperty"].asString();
+
+}
+
+std::string ReleaseArtifactResult::getStatus()const
+{
+	return status_;
+}
+
+std::string ReleaseArtifactResult::getArtifactVersion()const
+{
+	return artifactVersion_;
+}
+
+std::string ReleaseArtifactResult::getDescription()const
+{
+	return description_;
+}
+
+std::string ReleaseArtifactResult::getArtifactId()const
+{
+	return artifactId_;
+}
+
+std::string ReleaseArtifactResult::getArtifactType()const
+{
+	return artifactType_;
+}
+
+std::string ReleaseArtifactResult::getGmtModified()const
+{
+	return gmtModified_;
+}
+
+std::string ReleaseArtifactResult::getVersionName()const
+{
+	return versionName_;
+}
+
+std::string ReleaseArtifactResult::getArtifactProperty()const
+{
+	return artifactProperty_;
+}
+

computenestsupplier/src/model/UpdateArtifactRequest.cc

@@ -0,0 +1,71 @@
+/*
+ * 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/computenestsupplier/model/UpdateArtifactRequest.h>
+
+using AlibabaCloud::ComputeNestSupplier::Model::UpdateArtifactRequest;
+
+UpdateArtifactRequest::UpdateArtifactRequest()
+    : RpcServiceRequest("computenestsupplier", "2021-05-21", "UpdateArtifact") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateArtifactRequest::~UpdateArtifactRequest() {}
+
+std::string UpdateArtifactRequest::getDescription() const {
+  return description_;
+}
+
+void UpdateArtifactRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::vector<std::string> UpdateArtifactRequest::getSupportRegionIds() const {
+  return supportRegionIds_;
+}
+
+void UpdateArtifactRequest::setSupportRegionIds(const std::vector<std::string> &supportRegionIds) {
+  supportRegionIds_ = supportRegionIds;
+}
+
+std::string UpdateArtifactRequest::getArtifactId() const {
+  return artifactId_;
+}
+
+void UpdateArtifactRequest::setArtifactId(const std::string &artifactId) {
+  artifactId_ = artifactId;
+  setParameter(std::string("ArtifactId"), artifactId);
+}
+
+std::string UpdateArtifactRequest::getArtifactProperty() const {
+  return artifactProperty_;
+}
+
+void UpdateArtifactRequest::setArtifactProperty(const std::string &artifactProperty) {
+  artifactProperty_ = artifactProperty;
+  setParameter(std::string("ArtifactProperty"), artifactProperty);
+}
+
+std::string UpdateArtifactRequest::getVersionName() const {
+  return versionName_;
+}
+
+void UpdateArtifactRequest::setVersionName(const std::string &versionName) {
+  versionName_ = versionName;
+  setParameter(std::string("VersionName"), versionName);
+}
+

computenestsupplier/src/model/UpdateArtifactResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/computenestsupplier/model/UpdateArtifactResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ComputeNestSupplier;
+using namespace AlibabaCloud::ComputeNestSupplier::Model;
+
+UpdateArtifactResult::UpdateArtifactResult() :
+	ServiceResult()
+{}
+
+UpdateArtifactResult::UpdateArtifactResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateArtifactResult::~UpdateArtifactResult()
+{}
+
+void UpdateArtifactResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ArtifactId"].isNull())
+		artifactId_ = value["ArtifactId"].asString();
+	if(!value["ArtifactType"].isNull())
+		artifactType_ = value["ArtifactType"].asString();
+	if(!value["VersionName"].isNull())
+		versionName_ = value["VersionName"].asString();
+	if(!value["ArtifactVersion"].isNull())
+		artifactVersion_ = value["ArtifactVersion"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["GmtModified"].isNull())
+		gmtModified_ = value["GmtModified"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["ArtifactProperty"].isNull())
+		artifactProperty_ = value["ArtifactProperty"].asString();
+	if(!value["SupportRegionIds"].isNull())
+		supportRegionIds_ = value["SupportRegionIds"].asString();
+
+}
+
+std::string UpdateArtifactResult::getStatus()const
+{
+	return status_;
+}
+
+std::string UpdateArtifactResult::getArtifactVersion()const
+{
+	return artifactVersion_;
+}
+
+std::string UpdateArtifactResult::getDescription()const
+{
+	return description_;
+}
+
+std::string UpdateArtifactResult::getArtifactId()const
+{
+	return artifactId_;
+}
+
+std::string UpdateArtifactResult::getArtifactType()const
+{
+	return artifactType_;
+}
+
+std::string UpdateArtifactResult::getSupportRegionIds()const
+{
+	return supportRegionIds_;
+}
+
+std::string UpdateArtifactResult::getGmtModified()const
+{
+	return gmtModified_;
+}
+
+std::string UpdateArtifactResult::getVersionName()const
+{
+	return versionName_;
+}
+
+std::string UpdateArtifactResult::getArtifactProperty()const
+{
+	return artifactProperty_;
+}
+